imprimatur 0.3.0 → 0.5.0

data/ext/imprimatur_native/core/src/pdf/layout.rs

@@ -8,7 +8,7 @@ use std::fmt::{self, Arguments, Write as _};
 
 use super::font::Face;
 use super::objects::{Num, push_string};
-use crate::doc::{Document, Paragraph, Picture, Table};
+use crate::doc::{Document, Paragraph, Picture, Symbol, Table};
 use crate::style::{Align, Color};
 use crate::{Error, Result};
 use wrap::{Line, Look, wrap};
@@ -129,20 +129,30 @@ impl Layout {
     /// Draws picture `index` (`/Im{index}`), on a new page when it does not
     /// fit, as its alignment says.
     pub fn picture(&mut self, picture: &Picture, index: usize) {
-        let room = (self.content_width(), (-2.0f64).mul_add(self.margin, self.height));
-        let (width, height) = picture.size(room);
-        self.ensure_room(height);
-        let x = self.margin
-            + match picture.align.unwrap_or(Align::Left) {
-                Align::Left => 0.0,
-                Align::Center => (room.0 - width) / 2.0,
-                Align::Right => room.0 - width,
-            };
-        self.y -= height;
-        let (width, height, x, y) = (Num(width), Num(height), Num(x), Num(self.y));
+        let (width, height) = picture.size(self.room());
+        let (x, y) = self.place((width, height), picture.align);
+        let (width, height, x, y) = (Num(width), Num(height), Num(x), Num(y));
         emit(self.current(), format_args!("q {width} 0 0 {height} {x} {y} cm /Im{index} Do Q\n"));
-        self.y -= PARAGRAPH_GAP;
-        self.blank = false;
+        self.end_figure();
+    }
+
+    /// Draws a barcode as filled rectangles, one module a unit, the
+    /// coordinates flipped to run down from its top left corner.
+    pub fn symbol(&mut self, symbol: &Symbol) {
+        let (shapes, (width, height)) = symbol.placed(self.room());
+        let (x, y) = self.place((width, height), symbol.align);
+        let (columns, rows) = shapes.extent();
+        let (across, down) = (width / columns, height / rows);
+        let (fill, top, x) = (Fill(symbol.color), Num(y + height), Num(x));
+        let page = self.current();
+        // Four decimals: a module's size in hundredths of a point would be
+        // off by up to half a percent across the symbol.
+        emit(page, format_args!("q {fill} {across:.4} 0 0 {:.4} {x} {top} cm\n", -down));
+        for [x, y, run, rows] in &shapes.rects {
+            emit(page, format_args!("{x} {y} {run} {rows} re\n"));
+        }
+        page.extend_from_slice(b"f Q\n");
+        self.end_figure();
     }
 
     pub fn page_break(&mut self) {
@@ -166,6 +176,30 @@ impl Layout {
         self.pages
     }
 
+    /// The width and height between the margins.
+    const fn room(&self) -> (f64, f64) {
+        (self.content_width(), (-2.0f64).mul_add(self.margin, self.height))
+    }
+
+    /// Makes room for a figure of `size`, on a new page when it does not
+    /// fit, and returns its bottom left corner as `align` places it.
+    fn place(&mut self, (width, height): (f64, f64), align: Option<Align>) -> (f64, f64) {
+        self.ensure_room(height);
+        let x = self.margin
+            + match align.unwrap_or(Align::Left) {
+                Align::Left => 0.0,
+                Align::Center => (self.content_width() - width) / 2.0,
+                Align::Right => self.content_width() - width,
+            };
+        self.y -= height;
+        (x, self.y)
+    }
+
+    fn end_figure(&mut self) {
+        self.y -= PARAGRAPH_GAP;
+        self.blank = false;
+    }
+
     /// Starts a new page unless `needed` points fit above the bottom margin
     /// (or the page is still blank, where nothing would fit better).
     /// Returns whether it did.

data/ext/imprimatur_native/core/src/pdf/truetype/descriptor.rs

@@ -0,0 +1,129 @@
+//! TrueType metadata needed by a PDF `FontDescriptor`, in 1000-unit glyph space.
+
+#[cfg(test)]
+mod tests;
+
+use std::io::Write;
+
+use read_fonts::{
+    FontRead, FontRef, TableProvider,
+    tables::{head::MacStyle, os2::Os2, post::Post},
+    types::{NameId, Tag},
+};
+
+use crate::font::{TrueTypeFont, invalid};
+use crate::pdf::objects::{Num, PdfWriter};
+use crate::{Error, Result};
+
+pub struct Descriptor {
+    /// PostScript name, escaped as a PDF name (without its leading slash).
+    pub name: String,
+    bounds: [Num; 4],
+    ascent: Num,
+    descent: Num,
+    cap_height: Num,
+    italic_angle: Num,
+    flags: u32,
+    stem: Num,
+}
+
+impl Descriptor {
+    pub fn read(font: &TrueTypeFont<'_>) -> Result<Self> {
+        let tables = FontRef::new(font.as_bytes()).map_err(invalid)?;
+        let head = tables.head().map_err(invalid)?;
+        let post =
+            tables.table_data(Tag::new(b"post")).map(Post::read).transpose().map_err(invalid)?;
+        let os2 =
+            tables.table_data(Tag::new(b"OS/2")).map(Os2::read).transpose().map_err(invalid)?;
+        if let Some(os2) = &os2 {
+            let rights = os2.fs_type();
+            // Older fonts can set several rights bits; the least restrictive wins.
+            (rights & 0x0002 == 0 || rights & 0x000C != 0)
+                .ok_or(Error::UnsupportedFont("restricted font embedding"))?;
+            (rights & 0x0200 == 0).ok_or(Error::UnsupportedFont("bitmap-only font embedding"))?;
+            // The no-subsetting bit is compatible with embedding the complete font.
+        }
+        (head.x_min() <= head.x_max() && head.y_min() <= head.y_max())
+            .ok_or_else(|| invalid("inverted font bounding box"))?;
+        let metrics = font.metrics();
+        let scale = 1000.0 / f64::from(metrics.units_per_em);
+        let cap_height = os2
+            .as_ref()
+            .and_then(Os2::s_cap_height)
+            .filter(|height| *height > 0)
+            .unwrap_or(metrics.ascender);
+        let angle = post.as_ref().map_or(0.0, |post| post.italic_angle().to_f64());
+        // Symbolic: Identity-H is a CID encoding, not the standard Latin encoding.
+        let mut flags = 4;
+        if post.as_ref().is_some_and(|post| post.is_fixed_pitch() != 0) {
+            flags |= 1;
+        }
+        if angle != 0.0 || head.mac_style().contains(MacStyle::ITALIC) {
+            flags |= 64;
+        }
+        let family = os2.as_ref().map_or(0, |os2| os2.s_family_class() >> 8);
+        if (1..=7).contains(&family) {
+            flags |= 2;
+        } else if family == 10 {
+            flags |= 8;
+        }
+        let weight = os2.as_ref().map_or(400, |os2| os2.us_weight_class().clamp(1, 1000));
+        let stem_weight = f64::from(weight) / 65.0;
+        Ok(Self {
+            name: postscript_name(&tables)?,
+            bounds: [head.x_min(), head.y_min(), head.x_max(), head.y_max()]
+                .map(|value| Num(f64::from(value) * scale)),
+            ascent: Num(f64::from(metrics.ascender) * scale),
+            descent: Num(f64::from(metrics.descender) * scale),
+            // Older OS/2 tables lack cap height; the ascender is an approximation.
+            cap_height: Num(f64::from(cap_height) * scale),
+            italic_angle: Num(angle),
+            flags,
+            // TrueType has no stem-width field: estimate it from the weight class.
+            stem: Num(stem_weight.mul_add(stem_weight, 50.0)),
+        })
+    }
+
+    pub fn write<W: Write>(&self, pdf: &mut PdfWriter<W>, id: usize, file: usize) -> Result<()> {
+        let Self { name, bounds, ascent, descent, cap_height, italic_angle, flags, stem } = self;
+        let [left, bottom, right, top] = bounds;
+        pdf.object(
+            id,
+            format_args!(
+                "<< /Type /FontDescriptor /FontName /{name} /Flags {flags} \
+                 /FontBBox [{left} {bottom} {right} {top}] /ItalicAngle {italic_angle} \
+                 /Ascent {ascent} /Descent {descent} /CapHeight {cap_height} \
+                 /StemV {stem} /FontFile2 {file} 0 R >>"
+            ),
+        )
+    }
+}
+
+fn postscript_name(font: &FontRef<'_>) -> Result<String> {
+    let names = font.name().map_err(invalid)?;
+    for platform in [3, 0, 1] {
+        for record in names.name_record() {
+            if record.name_id() != NameId::POSTSCRIPT_NAME || record.platform_id() != platform {
+                continue;
+            }
+            if !(record.is_unicode() || platform == 1 && record.encoding_id() == 0) {
+                continue;
+            }
+            if record.is_unicode() && !record.length().is_multiple_of(2) {
+                return Err(invalid("odd UTF-16 PostScript name length"));
+            }
+            let name = record.string(names.string_data()).map_err(invalid)?.to_string();
+            // OpenType name ID 6: 1..63 printable ASCII characters, excluding
+            // PostScript delimiters. '#' is legal there but needs escaping in PDF.
+            if !name.is_empty()
+                && name.len() <= 63
+                && name
+                    .bytes()
+                    .all(|byte| (33..=126).contains(&byte) && !b"[](){}<>/%".contains(&byte))
+            {
+                return Ok(name.replace('#', "#23"));
+            }
+        }
+    }
+    Err(Error::UnsupportedFont("no usable PostScript font name"))
+}

data/ext/imprimatur_native/core/src/pdf/truetype/program.rs

@@ -0,0 +1,70 @@
+//! A `CIDFont`'s TrueType program retains every glyph but omits the cmap table
+//! (ISO 32000-1, 9.9). Rebuild the sfnt directory, padding and checksums; glyph
+//! outlines, IDs, metrics and hinting tables are unchanged.
+
+#[cfg(test)]
+mod tests;
+
+use read_fonts::{FontRef, TableRecord, types::Tag};
+
+use crate::Result;
+use crate::font::{TrueTypeFont, invalid};
+
+pub fn for_pdf(font: &TrueTypeFont<'_>) -> Result<Vec<u8>> {
+    let source = FontRef::new(font.as_bytes()).map_err(invalid)?;
+    let mut tags: Vec<_> = source
+        .table_directory()
+        .table_records()
+        .iter()
+        .map(TableRecord::tag)
+        // Rewriting the directory also invalidates any digital signature.
+        .filter(|tag| *tag != Tag::new(b"cmap") && *tag != Tag::new(b"DSIG"))
+        .collect();
+    tags.sort_unstable();
+    (!tags.windows(2).any(|pair| pair[0] == pair[1]))
+        .ok_or_else(|| invalid("duplicate sfnt tables"))?;
+    let count = u16::try_from(tags.len()).map_err(invalid)?;
+    // searchRange and rangeShift are byte counts in 16-bit fields.
+    (count > 0 && count <= 4095).ok_or_else(|| invalid("sfnt table count out of range"))?;
+    let selector = u16::try_from(count.ilog2()).map_err(invalid)?;
+    let range = (1_u16 << selector) * 16;
+    let mut data = Vec::with_capacity(font.as_bytes().len());
+    data.extend_from_slice(&font.as_bytes()[..4]);
+    for value in [count, range, selector, count * 16 - range] {
+        data.extend_from_slice(&value.to_be_bytes());
+    }
+    data.resize(12 + 16 * tags.len(), 0);
+    let mut head = None;
+    for (index, tag) in tags.into_iter().enumerate() {
+        let table = source.table_data(tag).ok_or_else(|| invalid("missing sfnt table"))?;
+        let start = data.len();
+        let offset = u32::try_from(start).map_err(invalid)?;
+        let length = u32::try_from(table.len()).map_err(invalid)?;
+        data.extend_from_slice(table.as_bytes());
+        if tag == Tag::new(b"head") {
+            // head's own checksum is calculated with checkSumAdjustment zero.
+            data[start + 8..start + 12].fill(0);
+            head = Some(start);
+        }
+        let sum = checksum(&data[start..]);
+        data.resize(data.len().next_multiple_of(4), 0);
+        let record = 12 + 16 * index;
+        data[record..record + 4].copy_from_slice(&tag.to_be_bytes());
+        for (field, value) in [sum, offset, length].into_iter().enumerate() {
+            let field = record + 4 * (field + 1);
+            data[field..field + 4].copy_from_slice(&value.to_be_bytes());
+        }
+    }
+    let head = head.ok_or_else(|| invalid("missing head table"))?;
+    let adjustment = 0xB1B0_AFBA_u32.wrapping_sub(checksum(&data));
+    data[head + 8..head + 12].copy_from_slice(&adjustment.to_be_bytes());
+    Ok(data)
+}
+
+fn checksum(data: &[u8]) -> u32 {
+    data.chunks(4).fold(0_u32, |sum, bytes| {
+        let mut word = [0; 4];
+        word[..bytes.len()].copy_from_slice(bytes);
+        sum.wrapping_add(u32::from_be_bytes(word))
+    })
+}

data/ext/imprimatur_native/core/src/pdf/truetype.rs

@@ -0,0 +1,149 @@
+//! A complete TrueType font as a horizontal Type 0 / `CIDFontType2` resource
+//! (ISO 32000-1, 9.7 and 9.10). Document font selection and layout are separate.
+
+mod descriptor;
+mod program;
+#[cfg(test)]
+mod tests;
+
+use std::collections::BTreeMap;
+use std::fmt::{self, Write as _};
+use std::io::Write;
+
+use super::objects::{Num, PdfWriter};
+use crate::font::TrueTypeFont;
+use crate::{Error, Result};
+use descriptor::Descriptor;
+
+/// Objects written in order: Type 0 font, descendant, descriptor, font file,
+/// CID-to-glyph map, `ToUnicode` character map.
+pub const OBJECTS: usize = 6;
+
+/// Collects glyph uses before writing the font resource once for all its pages.
+/// CIDs are allocated per (glyph, original text), not per glyph alone: distinct
+/// characters can share an outline, and a ligature can represent several.
+pub struct EmbeddedFont<'a> {
+    font: TrueTypeFont<'a>,
+    descriptor: Descriptor,
+    program: Vec<u8>,
+    /// CID 1 onwards, with unscaled advances; CID 0 is reserved for .notdef.
+    glyphs: Vec<(u16, u16)>,
+    codes: BTreeMap<(u16, String), u16>,
+}
+
+impl<'a> EmbeddedFont<'a> {
+    /// Reads the metadata needed for a PDF descriptor and checks embedding rights.
+    pub fn new(font: TrueTypeFont<'a>) -> Result<Self> {
+        let descriptor = Descriptor::read(&font)?;
+        let program = program::for_pdf(&font)?;
+        Ok(Self { font, descriptor, program, glyphs: Vec::new(), codes: BTreeMap::new() })
+    }
+
+    /// The two big-endian bytes to put in a PDF text string for this glyph use.
+    /// `text` is its original Unicode sequence, in logical order. Empty text
+    /// omits its `ToUnicode` entry, for glyphs with no text of their own.
+    /// This does not shape text or infer glyphs from characters.
+    pub fn encode_glyph(&mut self, glyph: u16, text: &str) -> Result<[u8; 2]> {
+        // A ToUnicode destination string may contain at most 512 bytes.
+        (text.encode_utf16().take(257).count() <= 256)
+            .ok_or_else(|| invalid("Unicode mapping exceeds 256 UTF-16 code units"))?;
+        let width = self
+            .font
+            .advance_width(glyph)
+            .filter(|_| glyph != 0)
+            .ok_or_else(|| invalid("glyph is missing or outside the font's glyph range"))?;
+        let key = (glyph, text.to_owned());
+        if let Some(code) = self.codes.get(&key) {
+            return Ok(code.to_be_bytes());
+        }
+        let code = u16::try_from(self.glyphs.len() + 1)
+            .map_err(|_| invalid("more than 65535 distinct glyph mappings"))?;
+        self.glyphs.push((glyph, width));
+        self.codes.insert(key, code);
+        Ok(code.to_be_bytes())
+    }
+
+    /// Writes six consecutive objects, starting at `first`, which is the font
+    /// reference for a page's resources. Collect every glyph before calling this.
+    /// Every glyph is embedded with its original ID and outline. The font's cmap
+    /// is replaced by PDF mappings; its table directory and checksums are rebuilt.
+    pub fn write<W: Write>(&self, pdf: &mut PdfWriter<W>, first: usize) -> Result<()> {
+        let (descendant, descriptor, file, mapping, unicode) =
+            (first + 1, first + 2, first + 3, first + 4, first + 5);
+        let name = &self.descriptor.name;
+        pdf.object(
+            first,
+            format_args!(
+                "<< /Type /Font /Subtype /Type0 /BaseFont /{name} /Encoding /Identity-H \
+                 /DescendantFonts [{descendant} 0 R] /ToUnicode {unicode} 0 R >>"
+            ),
+        )?;
+        let scale = 1000.0 / f64::from(self.font.metrics().units_per_em);
+        let default_width = Num(f64::from(self.font.advance_width(0).unwrap_or(0)) * scale);
+        let widths = fmt::from_fn(|f| {
+            // Keep both the outer W array and each inner width array below the
+            // PDF 1.7 implementation limit of 8191 elements (Annex C).
+            for (index, glyphs) in self.glyphs.chunks(256).enumerate() {
+                if index > 0 {
+                    f.write_str(" ")?;
+                }
+                write!(f, "{} [", 1 + index * 256)?;
+                for &(_, width) in glyphs {
+                    write!(f, "{} ", Num(f64::from(width) * scale))?;
+                }
+                f.write_str("]")?;
+            }
+            Ok(())
+        });
+        pdf.object(
+            descendant,
+            format_args!(
+                "<< /Type /Font /Subtype /CIDFontType2 /BaseFont /{name} \
+                 /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> \
+                 /FontDescriptor {descriptor} 0 R /DW {default_width} /W [{widths}] \
+                 /CIDToGIDMap {mapping} 0 R >>"
+            ),
+        )?;
+        self.descriptor.write(pdf, descriptor, file)?;
+        pdf.stream(file, &self.program, &[("Length1", &self.program.len())])?;
+        let mut gids = Vec::with_capacity(2 * (self.glyphs.len() + 1));
+        gids.extend_from_slice(&[0, 0]);
+        for &(glyph, _) in &self.glyphs {
+            gids.extend_from_slice(&glyph.to_be_bytes());
+        }
+        pdf.stream(mapping, &gids, &[])?;
+        pdf.stream(unicode, self.to_unicode().as_bytes(), &[])
+    }
+
+    fn to_unicode(&self) -> String {
+        let mut cmap = String::from(
+            "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n\
+             /CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n\
+             /CMapName /Imprimatur-UCS def\n/CMapType 2 def\n\
+             1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n",
+        );
+        let mappings: Vec<_> =
+            self.codes.iter().filter(|((_, text), _)| !text.is_empty()).collect();
+        // CMap mapping operators accept at most 100 entries per block.
+        for chunk in mappings.chunks(100) {
+            // Writing to a String cannot fail.
+            let _ = writeln!(cmap, "{} beginbfchar", chunk.len());
+            for ((_, text), code) in chunk {
+                // Writing to a String cannot fail.
+                let _ = write!(cmap, "<{code:04X}> <");
+                for unit in text.encode_utf16() {
+                    // Writing to a String cannot fail.
+                    let _ = write!(cmap, "{unit:04X}");
+                }
+                cmap.push_str(">\n");
+            }
+            cmap.push_str("endbfchar\n");
+        }
+        cmap.push_str("endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n");
+        cmap
+    }
+}
+
+fn invalid(reason: &str) -> Error {
+    Error::malformed("PDF font", reason)
+}

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

@@ -1,6 +1,7 @@
 //! PDF output: the document laid out with the standard Helvetica fonts
 //! (`WinAnsiEncoding`, so Windows-1252 text), written with our own object
-//! writer. Embedded TrueType fonts, and with them every other script, come next.
+//! writer. `truetype` serializes embedded font resources; connecting these to
+//! document layout, shaping and bidirectional text comes next.
 
 mod font;
 mod layout;
@@ -10,6 +11,12 @@ mod objects;
 mod picture;
 #[cfg(test)]
 mod tests;
+#[cfg(feature = "fonts")]
+#[cfg_attr(
+    not(test),
+    expect(dead_code, reason = "font resources are connected to document layout in a follow-up")
+)]
+mod truetype;
 
 use std::fmt;
 use std::io::Write;
@@ -38,6 +45,7 @@ pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
                 layout.picture(picture, pictures.len());
                 pictures.push(picture);
             }
+            Block::Symbol(symbol) => layout.symbol(symbol),
             Block::PageBreak => layout.page_break(),
         }
     }

data/ext/imprimatur_native/core/src/read/image.rs

@@ -128,6 +128,20 @@ pub fn png(
     bits: u8,
     palette: Option<&[u8]>,
     rows: &[u8],
+) -> Vec<u8> {
+    png_with_transparency(width, height, color, bits, palette, &[], rows)
+}
+
+/// As [`png`], with a `tRNS` chunk unless `transparency` is empty: a
+/// palette's alphas by index, or the gray or RGB color that is transparent.
+pub fn png_with_transparency(
+    width: u32,
+    height: u32,
+    color: PngColor,
+    bits: u8,
+    palette: Option<&[u8]>,
+    transparency: &[u8],
+    rows: &[u8],
 ) -> Vec<u8> {
     let channels: usize = match color {
         PngColor::Gray | PngColor::Palette => 1,
@@ -157,6 +171,9 @@ pub fn png(
     if let Some(palette) = palette {
         chunk(&mut out, *b"PLTE", palette);
     }
+    if !transparency.is_empty() {
+        chunk(&mut out, *b"tRNS", transparency);
+    }
     chunk(&mut out, *b"IDAT", &compressed);
     chunk(&mut out, *b"IEND", &[]);
     out

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

@@ -38,9 +38,10 @@ pub use content::{
     Block, Bounds, Cell, Columns, Content, Grid, Look, Mark, Note, Page, Placed, Sheet, Styled,
     Text, Validation, Value,
 };
-pub use image::{Image, ImageFormat, ImageLocation};
 #[cfg(test)]
-pub(crate) use image::{PngColor, png};
+pub(crate) use image::png;
+pub use image::{Image, ImageFormat, ImageLocation};
+pub(crate) use image::{PngColor, png_with_transparency};
 
 use crate::zip::reader::ZipReader;
 use crate::{Error, Result};

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

@@ -41,6 +41,17 @@ impl Color {
     pub(crate) fn argb(self) -> String {
         format!("FF{:06X}", self.0)
     }
+
+    /// `#RRGGBB`, as SVG takes it.
+    pub(crate) fn hex(self) -> String {
+        format!("#{:06X}", self.0)
+    }
+
+    /// Red, green and blue bytes.
+    pub(crate) const fn bytes(self) -> [u8; 3] {
+        let [_, r, g, b] = self.0.to_be_bytes();
+        [r, g, b]
+    }
 }
 
 /// Horizontal alignment within the cell.

data/ext/imprimatur_native/ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imprimatur_native"
-version = "0.3.0"
+version = "0.5.0"
 description = "Ruby bindings for the imprimatur crate"
 publish = false
 edition.workspace = true

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(())
+}