imprimatur 0.2.0 → 0.4.0

data/ext/imprimatur_native/core/src/xlsx/format.rs

@@ -132,7 +132,7 @@ impl Format {
         if length == 0 || length > MAX_FONT_NAME || name.chars().any(char::is_control) {
             return Err(Error::InvalidFontName(name));
         }
-        self.font.name = (name != DEFAULT_FONT).then_some(name);
+        self.font.name = Some(name);
         Ok(self)
     }
 
@@ -147,7 +147,7 @@ impl Format {
         #[expect(clippy::cast_possible_truncation, reason = "a whole number from 2 to 818")]
         #[expect(clippy::cast_sign_loss, reason = "a whole number from 2 to 818")]
         let half_points = half_points as u16;
-        self.font.half_points = (half_points != DEFAULT_HALF_POINTS).then_some(half_points);
+        self.font.half_points = Some(half_points);
         Ok(self)
     }
 
@@ -213,13 +213,29 @@ pub struct Font {
 }
 
 impl Font {
-    pub(crate) fn name(&self) -> &str {
-        self.name.as_deref().unwrap_or(DEFAULT_FONT)
+    /// No name or size of its own: the workbook's, Calibri 11 by default.
+    pub(crate) const BASE: Self = Self {
+        bold: false,
+        italic: false,
+        underline: false,
+        color: None,
+        name: None,
+        half_points: None,
+    };
+
+    /// Its name, or else the workbook's `base` one.
+    pub(crate) fn name<'a>(&'a self, base: &'a Self) -> &'a str {
+        self.name.as_deref().or(base.name.as_deref()).unwrap_or(DEFAULT_FONT)
+    }
+
+    /// Its size in half points, or else the workbook's `base` one.
+    pub(crate) fn half_points(&self, base: &Self) -> u16 {
+        self.half_points.or(base.half_points).unwrap_or(DEFAULT_HALF_POINTS)
     }
 
     /// The size in points as `<sz>` writes it: `11`, `10.5`.
-    pub(crate) fn size(&self) -> String {
-        let half_points = self.half_points.unwrap_or(DEFAULT_HALF_POINTS);
+    pub(crate) fn size(&self, base: &Self) -> String {
+        let half_points = self.half_points(base);
         let whole = half_points / 2;
         if half_points.is_multiple_of(2) { whole.to_string() } else { format!("{whole}.5") }
     }

data/ext/imprimatur_native/core/src/xlsx/package.rs

@@ -1,10 +1,13 @@
 //! The parts of an `.xlsx` package and the relationships between them.
 
+use std::collections::BTreeMap;
 use std::fmt::Write as _;
 use std::io::Write;
 
+use super::autofit;
 use super::cell::{Cell, cell_reference, push_cell_reference};
 use super::comment;
+use super::format::Font;
 use super::styles::Stylesheet;
 use super::text::{SharedStrings, escape, needs_preserve};
 use super::validation;
@@ -28,7 +31,9 @@ const DRAWING_ID: &str = "rId2";
 /// compressed and dropped before the next is built, so only one sheet's XML
 /// is in memory at a time; the styles and the shared string table, complete
 /// only after every sheet, follow them.
-pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
+/// `font` is the workbook's: unformatted cells', and the formats' with no
+/// name or size.
+pub fn write<W: Write>(sheets: &[Worksheet], font: &Font, out: W) -> Result<W> {
     if sheets.is_empty() {
         return Err(Error::EmptyWorkbook);
     }
@@ -57,7 +62,7 @@ pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
     for (number, sheet) in (1..).zip(sheets) {
         let remap = styles.add_sheet(sheet)?;
         set(&mut name, format_args!("xl/worksheets/sheet{number}.xml"));
-        zip.add(&name, worksheet(sheet, &remap, &mut strings).as_bytes())?;
+        zip.add(&name, worksheet(sheet, &remap, &mut strings, font).as_bytes())?;
         let comments = sheet.comments();
         if comments.is_empty() {
             continue;
@@ -74,7 +79,7 @@ pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
         next_block += comment::blocks_for(comments.len());
     }
     debug_assert_eq!(has_strings, !strings.is_empty(), "the text scan matches the table");
-    zip.add("xl/styles.xml", styles.to_xml().as_bytes())?;
+    zip.add("xl/styles.xml", styles.to_xml(font).as_bytes())?;
     if has_strings {
         zip.add("xl/sharedStrings.xml", strings.to_xml().as_bytes())?;
     }
@@ -137,7 +142,12 @@ fn workbook(sheets: &[Worksheet]) -> String {
 
 /// `remap` turns the sheet's own style ids into the workbook's. The cell
 /// loop formats into three scratch buffers instead of allocating per cell.
-fn worksheet<'a>(sheet: &'a Worksheet, remap: &[u32], strings: &mut SharedStrings<'a>) -> String {
+fn worksheet<'a>(
+    sheet: &'a Worksheet,
+    remap: &[u32],
+    strings: &mut SharedStrings<'a>,
+    font: &Font,
+) -> String {
     let mut xml = XmlWriter::new();
     xml.open("worksheet", &[("xmlns", MAIN_NS), ("xmlns:r", opc::RELATIONSHIPS)]);
     xml.empty("dimension", &[("ref", &dimension(sheet))]);
@@ -146,7 +156,7 @@ fn worksheet<'a>(sheet: &'a Worksheet, remap: &[u32], strings: &mut SharedString
         xml.empty("sheetView", &[("rightToLeft", "1"), ("workbookViewId", "0")]);
         xml.close("sheetViews");
     }
-    write_columns(&mut xml, sheet);
+    write_columns(&mut xml, sheet, font);
     xml.open("sheetData", &[]);
     let (mut reference, mut style, mut value) = (String::new(), String::new(), String::new());
     for (row, cells) in sheet.rows() {
@@ -216,13 +226,17 @@ fn set(buffer: &mut String, value: impl std::fmt::Display) {
 }
 
 /// `<cols>`: one `<col>` per run of adjacent columns with the same width.
-fn write_columns(xml: &mut XmlWriter, sheet: &Worksheet) {
-    let widths = sheet.column_widths();
+/// The columns' widths: those set, and for an autofit sheet those its cells
+/// need.
+fn write_columns(xml: &mut XmlWriter, sheet: &Worksheet, font: &Font) {
+    let mut widths =
+        if sheet.is_autofit() { autofit::widths(sheet, font) } else { BTreeMap::new() };
+    widths.extend(sheet.column_widths());
     if widths.is_empty() {
         return;
     }
     let mut runs: Vec<(u16, u16, f64)> = Vec::new();
-    for (&column, &width) in widths {
+    for (column, width) in widths {
         match runs.last_mut() {
             Some((_, last, run_width))
                 if *last + 1 == column && run_width.to_bits() == width.to_bits() =>

data/ext/imprimatur_native/core/src/xlsx/styles.rs

@@ -70,7 +70,8 @@ impl Stylesheet {
         Ok(remap)
     }
 
-    pub fn to_xml(&self) -> String {
+    /// The stylesheet, fonts without a name or size of their own in `base`.
+    pub fn to_xml(&self, base: &Font) -> String {
         let mut number_formats = Table::<&str>::new(FIRST_CUSTOM_NUMBER_FORMAT);
         let mut fonts = Table::<&Font>::new(1);
         let mut fills = Table::<Color>::new(2);
@@ -101,7 +102,7 @@ impl Stylesheet {
             }
             xml.close("numFmts");
         }
-        write_fonts(&mut xml, &fonts.order);
+        write_fonts(&mut xml, &fonts.order, base);
         write_fills(&mut xml, &fills.order);
         write_borders(&mut xml, &borders.order);
         xml.open("cellStyleXfs", &[("count", "1")]);
@@ -131,24 +132,24 @@ impl Stylesheet {
     }
 }
 
-fn write_fonts(xml: &mut XmlWriter, fonts: &[&Font]) {
+/// Font 0, the one of unformatted cells, is `base`.
+fn write_fonts(xml: &mut XmlWriter, fonts: &[&Font], base: &Font) {
     let count = (fonts.len() + 1).to_string();
     xml.open("fonts", &[("count", &count)]);
-    let default = Font::default();
-    for font in std::iter::once(&default).chain(fonts.iter().copied()) {
+    for font in std::iter::once(base).chain(fonts.iter().copied()) {
         xml.open("font", &[]);
         for (on, tag) in [(font.bold, "b"), (font.italic, "i"), (font.underline, "u")] {
             if on {
                 xml.empty(tag, &[]);
             }
         }
-        xml.empty("sz", &[("val", &font.size())]);
+        xml.empty("sz", &[("val", &font.size(base))]);
         if let Some(color) = font.color {
             xml.empty("color", &[("rgb", &color.argb())]);
         }
-        xml.empty("name", &[("val", font.name())]);
+        xml.empty("name", &[("val", font.name(base))]);
         // The family is a fallback hint; only Calibri's is known (2, swiss).
-        if font.name() == DEFAULT_FONT {
+        if font.name(base) == DEFAULT_FONT {
             xml.empty("family", &[("val", "2")]);
         }
         xml.close("font");

data/ext/imprimatur_native/core/src/xlsx/worksheet.rs

@@ -6,6 +6,7 @@ use std::sync::Arc;
 
 use super::text::check_length;
 use super::{Cell, CellRange, Comment, Format, Validation};
+use crate::script::Counts;
 use crate::{Error, Result};
 
 /// Rows in a sheet (Excel 2007 and later).
@@ -40,7 +41,9 @@ pub struct Worksheet {
     /// The style of an unformatted date, then of an unformatted date and time.
     date_styles: [Option<u32>; 2],
     widths: BTreeMap<u16, f64>,
-    right_to_left: bool,
+    autofit: bool,
+    /// As set; `None` to follow the sheet's text.
+    right_to_left: Option<bool>,
     validations: Vec<(CellRange, Validation)>,
     comments: BTreeMap<(u32, u16), Comment>,
 }
@@ -55,7 +58,8 @@ impl Worksheet {
             format_ids: HashMap::new(),
             date_styles: [None; 2],
             widths: BTreeMap::new(),
-            right_to_left: false,
+            autofit: false,
+            right_to_left: None,
             validations: Vec::new(),
             comments: BTreeMap::new(),
         }
@@ -174,16 +178,40 @@ impl Worksheet {
         Ok(self)
     }
 
-    /// Lays the sheet out right to left: column `A` on the right, as Excel
-    /// shows sheets for Arabic and Hebrew.
+    /// Sizes the columns without a width of their own to their widest cell,
+    /// estimated from its characters and font as
+    /// `(characters + 3) × points / 10`, bold one and a half times wider.
+    pub const fn set_autofit(&mut self, autofit: bool) -> &mut Self {
+        self.autofit = autofit;
+        self
+    }
+
+    #[must_use]
+    pub const fn is_autofit(&self) -> bool {
+        self.autofit
+    }
+
+    /// Lays the sheet out right to left, column `A` on the right, as Excel
+    /// shows sheets for Arabic and Hebrew; or left to right. Without a
+    /// call, a sheet is right to left when most of the letters of its name
+    /// and text cells are.
     pub const fn set_right_to_left(&mut self, right_to_left: bool) -> &mut Self {
-        self.right_to_left = right_to_left;
+        self.right_to_left = Some(right_to_left);
         self
     }
 
     #[must_use]
-    pub const fn is_right_to_left(&self) -> bool {
-        self.right_to_left
+    pub fn is_right_to_left(&self) -> bool {
+        self.right_to_left.unwrap_or_else(|| {
+            let mut counts = Counts::default();
+            counts.add(&self.name);
+            for entry in self.rows.values().flat_map(BTreeMap::values) {
+                if let Cell::Text(text) = &entry.cell {
+                    counts.add(text);
+                }
+            }
+            counts.right_to_left()
+        })
     }
 
     /// Applies a rule to the cells of `range`, whether or not they hold values.

data/ext/imprimatur_native/core/src/xlsx.rs

@@ -1,5 +1,6 @@
 //! `SpreadsheetML` (`.xlsx`) workbooks, per ECMA-376 Part 1.
 
+mod autofit;
 mod cell;
 mod comment;
 mod date;
@@ -22,6 +23,9 @@ pub(crate) use cell::push_cell_reference;
 pub use cell::{Cell, cell_reference, column_name};
 pub use comment::Comment;
 pub use date::DateTime;
+#[cfg(feature = "archive")]
+pub(crate) use date::civil_from_days;
+use format::Font;
 pub use format::{Border, Format, VerticalAlign};
 pub use range::{CellRange, parse_cell_reference};
 pub use validation::{Alert, Validation};
@@ -36,12 +40,44 @@ const MAX_SHEET_NAME: usize = 31;
 #[derive(Debug, Default)]
 pub struct Workbook {
     sheets: Vec<Worksheet>,
+    /// The font of unformatted cells, and of formats with no name or size.
+    font: Font,
+    /// Whether new sheets size their columns to their cells.
+    autofit: bool,
 }
 
 impl Workbook {
     #[must_use]
     pub const fn new() -> Self {
-        Self { sheets: Vec::new() }
+        Self { sheets: Vec::new(), font: Font::BASE, autofit: false }
+    }
+
+    /// The font of cells without a format, and of formats that name no font:
+    /// Calibri unless set.
+    ///
+    /// # Errors
+    /// [`Error::InvalidFontName`] for an empty name, one longer than 31
+    /// characters or with a control character.
+    pub fn set_font_name(&mut self, name: impl Into<String>) -> Result<&mut Self> {
+        self.font.name = Format::new().font_name(name)?.font.name;
+        Ok(self)
+    }
+
+    /// The size of cells without a format, and of formats that set none: 11
+    /// points unless set.
+    ///
+    /// # Errors
+    /// [`Error::InvalidFontSize`] outside 1 to 409 points in steps of 0.5.
+    pub fn set_font_size(&mut self, points: f64) -> Result<&mut Self> {
+        self.font.half_points = Format::new().font_size(points)?.font.half_points;
+        Ok(self)
+    }
+
+    /// Whether the sheets added from now on size their columns to their
+    /// cells, as [`Worksheet::set_autofit`] does.
+    pub const fn set_autofit(&mut self, autofit: bool) -> &mut Self {
+        self.autofit = autofit;
+        self
     }
 
     /// Adds a sheet after the existing ones and returns it for writing.
@@ -56,7 +92,8 @@ impl Workbook {
         if self.sheets.iter().any(|sheet| sheet.name().to_lowercase() == folded) {
             return Err(Error::DuplicateSheetName(name));
         }
-        Ok(self.sheets.push_mut(Worksheet::new(name)))
+        let autofit = self.autofit;
+        Ok(self.sheets.push_mut(Worksheet::new(name)).set_autofit(autofit))
     }
 
     #[must_use]
@@ -73,7 +110,7 @@ impl Workbook {
     /// # Errors
     /// [`Error::EmptyWorkbook`] without sheets, [`Error::Io`] when `out` fails.
     pub fn write_to<W: Write>(&self, out: W) -> Result<W> {
-        package::write(&self.sheets, out)
+        package::write(&self.sheets, &self.font, out)
     }
 
     /// The `.xlsx` package as bytes.

data/ext/imprimatur_native/core/src/xml/reader.rs

@@ -57,6 +57,16 @@ impl<'a> Tag<'a> {
         }
     }
 
+    /// The attribute parsed: `None` when it is missing or does not parse.
+    pub fn parse<T: std::str::FromStr>(&self, local: &str) -> Option<T> {
+        self.attr(local)?.parse().ok()
+    }
+
+    /// Whether the attribute is there and on: `1`, `true` or `on`.
+    pub fn on(&self, local: &str) -> bool {
+        self.attr(local).is_some() && self.flag(local)
+    }
+
     /// `w:val`-style booleans: present without a value, `1`, `true` or
     /// `on` are true; Word writes `w:val="0"` to switch a property off.
     pub fn flag(&self, local: &str) -> bool {

data/ext/imprimatur_native/ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imprimatur_native"
-version = "0.2.0"
+version = "0.4.0"
 description = "Ruby bindings for the imprimatur crate"
 publish = false
 edition.workspace = true
@@ -15,7 +15,8 @@ crate-type = ["cdylib"]
 workspace = true
 
 [dependencies]
-imprimatur = { workspace = true, features = ["archive", "json"] }
+# Gems ship precompiled, so they carry every feature of the crate.
+imprimatur = { workspace = true, features = ["archive", "fonts", "json"] }
 serde_json.workspace = true
 magnus.workspace = true
 rb-sys.workspace = true

data/ext/imprimatur_native/ffi/src/archive.rs

@@ -45,9 +45,7 @@ impl ZipWriter {
         data: RString,
         comment: Option<String>,
     ) -> Result<(), Error> {
-        // SAFETY: the bytes are copied out at once, while the GVL is held.
-        #[allow(unsafe_code)]
-        let data = unsafe { data.as_slice() }.to_vec();
+        let data = crate::bytes(data);
         let mut slot = borrow(ruby, &rb_self.0, "zip writer")?;
         let writer = slot.as_mut().ok_or_else(|| finished(ruby))?;
         without_gvl(ruby, || writer.add(&name, &data, comment.as_deref()))?.or_raise(ruby)

data/ext/imprimatur_native/ffi/src/barcode.rs

@@ -0,0 +1,147 @@
+//! `Imprimatur::Barcode`: a barcode symbol, drawn as SVG or PNG or placed in
+//! a document. `lib/imprimatur/barcode.rb` owns the keyword interface.
+
+use imprimatur::barcode::{self, Level, Look, Symbology};
+use imprimatur::style::Color;
+use magnus::{Error, RString, Ruby, Symbol};
+
+use crate::{OrRaise, argument_error, keyword};
+
+#[magnus::wrap(class = "Imprimatur::Barcode", free_immediately, size)]
+pub struct Barcode(pub barcode::Barcode);
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Kind {
+    Qr,
+    DataMatrix,
+    Ean13,
+    Ean8,
+    UpcA,
+    Code128,
+}
+
+const KINDS: [(&str, Kind); 6] = [
+    ("qr", Kind::Qr),
+    ("datamatrix", Kind::DataMatrix),
+    ("ean13", Kind::Ean13),
+    ("ean8", Kind::Ean8),
+    ("upca", Kind::UpcA),
+    ("code128", Kind::Code128),
+];
+const LEVELS: [(&str, Level); 4] =
+    [("l", Level::Low), ("m", Level::Medium), ("q", Level::Quartile), ("h", Level::High)];
+
+#[expect(clippy::needless_pass_by_value, reason = "magnus passes Ruby arguments as owned values")]
+impl Barcode {
+    /// Called by `Imprimatur::Barcode.encode`.
+    pub fn encode(
+        ruby: &Ruby,
+        symbology: String,
+        data: String,
+        gs1: bool,
+        level: Option<String>,
+    ) -> Result<Self, Error> {
+        let kind = keyword(ruby, "symbology", &symbology, &KINDS)?;
+        let level = level.map(|level| keyword(ruby, "level", &level, &LEVELS)).transpose()?;
+        if level.is_some() && kind != Kind::Qr {
+            return Err(argument_error(ruby, "level: applies to :qr only"));
+        }
+        if gs1 && !matches!(kind, Kind::Qr | Kind::DataMatrix | Kind::Code128) {
+            return Err(argument_error(ruby, "gs1: applies to :qr, :datamatrix and :code128"));
+        }
+        let level = level.unwrap_or_default();
+        let code = match (kind, gs1) {
+            (Kind::Qr, false) => barcode::Barcode::qr(&data, level),
+            (Kind::Qr, true) => barcode::Barcode::gs1_qr(&data, level),
+            (Kind::DataMatrix, false) => barcode::Barcode::data_matrix(&data),
+            (Kind::DataMatrix, true) => barcode::Barcode::gs1_data_matrix(&data),
+            (Kind::Ean13, _) => barcode::Barcode::ean13(&data),
+            (Kind::Ean8, _) => barcode::Barcode::ean8(&data),
+            (Kind::UpcA, _) => barcode::Barcode::upc_a(&data),
+            (Kind::Code128, false) => barcode::Barcode::code128(&data),
+            (Kind::Code128, true) => barcode::Barcode::gs1_128(&data),
+        };
+        Ok(Self(code.or_raise(ruby)?))
+    }
+
+    fn svg(
+        ruby: &Ruby,
+        rb_self: &Self,
+        module: f64,
+        look: (String, Option<String>, bool, Option<u32>),
+    ) -> Result<String, Error> {
+        rb_self.0.svg(module, &self::look(ruby, look)?).or_raise(ruby)
+    }
+
+    /// The PNG as a binary String.
+    fn png(
+        ruby: &Ruby,
+        rb_self: &Self,
+        scale: u32,
+        look: (String, Option<String>, bool, Option<u32>),
+    ) -> Result<RString, Error> {
+        let png = rb_self.0.png(scale, &self::look(ruby, look)?).or_raise(ruby)?;
+        Ok(ruby.str_from_slice(&png))
+    }
+
+    fn symbology(ruby: &Ruby, rb_self: &Self) -> Symbol {
+        let name = match rb_self.0.symbology() {
+            Symbology::QrCode => "qr",
+            Symbology::DataMatrix => "datamatrix",
+            Symbology::Ean13 => "ean13",
+            Symbology::Ean8 => "ean8",
+            Symbology::UpcA => "upca",
+            _ => "code128",
+        };
+        ruby.to_symbol(name)
+    }
+
+    fn text(&self) -> String {
+        self.0.text().to_owned()
+    }
+
+    const fn is_gs1(&self) -> bool {
+        self.0.is_gs1()
+    }
+
+    const fn width(&self) -> usize {
+        self.0.size().0
+    }
+
+    const fn height(&self) -> usize {
+        self.0.size().1
+    }
+
+    /// Rows of modules, true for dark ones.
+    fn modules(&self) -> Vec<Vec<bool>> {
+        let (columns, rows) = self.0.size();
+        (0..rows).map(|y| (0..columns).map(|x| self.0.is_dark(x, y)).collect()).collect()
+    }
+}
+
+/// `[color, background, quiet_zone, bar_height]`, as `Imprimatur::Barcode`
+/// passes them.
+fn look(
+    ruby: &Ruby,
+    (dark, light, quiet_zone, bar_height): (String, Option<String>, bool, Option<u32>),
+) -> Result<Look, Error> {
+    let dark = Color::from_hex(&dark).or_raise(ruby)?;
+    let light = light.map(|light| Color::from_hex(&light)).transpose().or_raise(ruby)?;
+    Ok(Look { dark, light, quiet_zone, bar_height })
+}
+
+pub fn define(ruby: &Ruby, imprimatur: magnus::RModule) -> Result<(), Error> {
+    use magnus::{function, method, prelude::*};
+
+    let class = imprimatur.define_class("Barcode", ruby.class_object())?;
+    class.define_singleton_method("__encode", function!(Barcode::encode, 4))?;
+    class.define_method("__svg", method!(Barcode::svg, 2))?;
+    class.define_method("__png", method!(Barcode::png, 2))?;
+    class.define_method("symbology", method!(Barcode::symbology, 0))?;
+    class.define_method("text", method!(Barcode::text, 0))?;
+    class.define_method("gs1?", method!(Barcode::is_gs1, 0))?;
+    class.define_method("width", method!(Barcode::width, 0))?;
+    class.define_method("height", method!(Barcode::height, 0))?;
+    class.define_method("modules", method!(Barcode::modules, 0))?;
+    Ok(())
+}

data/ext/imprimatur_native/ffi/src/document.rs

@@ -2,10 +2,11 @@
 
 use std::cell::RefCell;
 
-use imprimatur::doc::{Document, PageSize, Paragraph, Run, Table};
+use imprimatur::doc::{Document, PageSize, Paragraph, Picture, Run, Symbol, Table};
 use imprimatur::style::Color;
 use magnus::{Error, RModule, RString, Ruby, function, method, prelude::*};
 
+use crate::barcode::Barcode;
 use crate::{ALIGNS, DIRECTIONS, OrRaise, RubyBytes, borrow, keyword};
 
 /// `[text, bold, italic, underline, color]`, as `Imprimatur::Paragraph` collects it.
@@ -40,10 +41,80 @@ impl NativeDocument {
             &size,
             &[("a4", PageSize::A4), ("letter", PageSize::Letter)],
         )?;
+        Self::page(ruby, rb_self, size, page_numbers)
+    }
+
+    /// A page `width` by `height` points.
+    fn set_page_points(
+        ruby: &Ruby,
+        rb_self: &Self,
+        width: f64,
+        height: f64,
+        page_numbers: bool,
+    ) -> Result<(), Error> {
+        let size = PageSize::custom(width, height).or_raise(ruby)?;
+        Self::page(ruby, rb_self, size, page_numbers)
+    }
+
+    fn page(ruby: &Ruby, rb_self: &Self, size: PageSize, page_numbers: bool) -> Result<(), Error> {
         borrow(ruby, &rb_self.0, "document")?.set_page_size(size).set_page_numbers(page_numbers);
         Ok(())
     }
 
+    fn set_margin(ruby: &Ruby, rb_self: &Self, points: f64) -> Result<(), Error> {
+        borrow(ruby, &rb_self.0, "document")?.set_margin(points).or_raise(ruby)?;
+        Ok(())
+    }
+
+    /// A PNG or JPEG from its bytes, `width` and `height` in points.
+    fn picture(
+        ruby: &Ruby,
+        rb_self: &Self,
+        data: RString,
+        width: Option<f64>,
+        height: Option<f64>,
+        align: Option<String>,
+    ) -> Result<(), Error> {
+        let mut picture = Picture::new(crate::bytes(data)).or_raise(ruby)?;
+        if let Some(width) = width {
+            picture = picture.width(width).or_raise(ruby)?;
+        }
+        if let Some(height) = height {
+            picture = picture.height(height).or_raise(ruby)?;
+        }
+        if let Some(align) = align {
+            picture = picture.align(keyword(ruby, "align", &align, &ALIGNS)?);
+        }
+        borrow(ruby, &rb_self.0, "document")?.picture(picture);
+        Ok(())
+    }
+
+    /// A barcode, `width` and `height` in points, in a `color` "#RRGGBB".
+    fn barcode(
+        ruby: &Ruby,
+        rb_self: &Self,
+        barcode: &Barcode,
+        (width, height): (Option<f64>, Option<f64>),
+        align: Option<String>,
+        color: Option<String>,
+    ) -> Result<(), Error> {
+        let mut symbol = Symbol::new(barcode.0.clone());
+        if let Some(width) = width {
+            symbol = symbol.width(width).or_raise(ruby)?;
+        }
+        if let Some(height) = height {
+            symbol = symbol.height(height).or_raise(ruby)?;
+        }
+        if let Some(align) = align {
+            symbol = symbol.align(keyword(ruby, "align", &align, &ALIGNS)?);
+        }
+        if let Some(color) = color {
+            symbol = symbol.color(Color::from_hex(&color).or_raise(ruby)?);
+        }
+        borrow(ruby, &rb_self.0, "document")?.barcode(symbol);
+        Ok(())
+    }
+
     fn heading(ruby: &Ruby, rb_self: &Self, level: u8, text: String) -> Result<(), Error> {
         borrow(ruby, &rb_self.0, "document")?.heading(level, text).or_raise(ruby)?;
         Ok(())
@@ -128,6 +199,10 @@ pub fn define(ruby: &Ruby, native: RModule) -> Result<(), Error> {
     let class = native.define_class("Document", ruby.class_object())?;
     class.define_singleton_method("new", function!(NativeDocument::new, 0))?;
     class.define_method("set_page", method!(NativeDocument::set_page, 2))?;
+    class.define_method("set_page_points", method!(NativeDocument::set_page_points, 3))?;
+    class.define_method("set_margin", method!(NativeDocument::set_margin, 1))?;
+    class.define_method("picture", method!(NativeDocument::picture, 4))?;
+    class.define_method("barcode", method!(NativeDocument::barcode, 4))?;
     class.define_method("heading", method!(NativeDocument::heading, 2))?;
     class.define_method("paragraph", method!(NativeDocument::paragraph, 3))?;
     class.define_method("table", method!(NativeDocument::table, 2))?;