imprimatur 0.1.0 → 0.2.0

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

@@ -161,3 +161,90 @@ pub fn tiff_of(data: &[u8]) -> (std::collections::BTreeMap<u16, u32>, &[u8]) {
     let (offset, length) = (tags[&273] as usize, tags[&279] as usize);
     (tags, &data[offset..offset + length])
 }
+
+/// A compound file (MS-CFB, version 3) holding one stream named `name` in
+/// its root storage; a stream under 4096 bytes goes to the mini stream, as
+/// writers put it.
+pub fn ole_of(name: &str, stream: &[u8]) -> Vec<u8> {
+    const SECTOR: usize = 512;
+    const END: u32 = 0xFFFF_FFFE;
+    let small = stream.len() < 4096;
+    let pad = |data: &[u8], size: usize| {
+        let mut data = data.to_vec();
+        data.resize(data.len().div_ceil(size).max(1) * size, 0);
+        data
+    };
+    // Sectors: FAT, directory, mini FAT (when small), then the data: the
+    // stream itself, or the mini stream holding it.
+    let data = if small { pad(stream, 64) } else { stream.to_vec() };
+    let data_sectors = data.len().div_ceil(SECTOR).max(1);
+    let first_data = if small { 3 } else { 2 };
+    let mut fat = vec![0xFFFF_FFFD_u32, END];
+    if small {
+        fat.push(END);
+    }
+    fat.extend((0..data_sectors).map(|index| {
+        if index + 1 == data_sectors { END } else { u32::try_from(first_data + index + 1).unwrap() }
+    }));
+    fat.resize(SECTOR / 4, 0xFFFF_FFFF);
+    let mut header = vec![0_u8; SECTOR];
+    header[..8].copy_from_slice(&[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]);
+    let put = |bytes: &mut Vec<u8>, at: usize, value: u32| {
+        bytes[at..at + 4].copy_from_slice(&value.to_le_bytes());
+    };
+    header[0x18..0x1A].copy_from_slice(&0x3E_u16.to_le_bytes());
+    header[0x1A..0x1C].copy_from_slice(&3_u16.to_le_bytes());
+    header[0x1C..0x1E].copy_from_slice(&0xFFFE_u16.to_le_bytes());
+    header[0x1E..0x20].copy_from_slice(&9_u16.to_le_bytes());
+    header[0x20..0x22].copy_from_slice(&6_u16.to_le_bytes());
+    put(&mut header, 0x2C, 1);
+    put(&mut header, 0x30, 1);
+    put(&mut header, 0x38, 4096);
+    put(&mut header, 0x3C, if small { 2 } else { END });
+    put(&mut header, 0x40, u32::from(small));
+    put(&mut header, 0x44, END);
+    put(&mut header, 0x4C, 0);
+    for index in 1..109 {
+        put(&mut header, 0x4C + index * 4, 0xFFFF_FFFF);
+    }
+    let entry = |name: &str, kind: u8, child: u32, start: u32, size: usize| {
+        let mut bytes = vec![0_u8; 128];
+        let units: Vec<u16> = name.encode_utf16().collect();
+        for (index, unit) in units.iter().enumerate() {
+            bytes[index * 2..index * 2 + 2].copy_from_slice(&unit.to_le_bytes());
+        }
+        bytes[0x40..0x42]
+            .copy_from_slice(&u16::try_from(units.len() * 2 + 2).unwrap().to_le_bytes());
+        bytes[0x42] = kind;
+        for at in [0x44, 0x48, 0x4C] {
+            put(&mut bytes, at, 0xFFFF_FFFF);
+        }
+        put(&mut bytes, 0x4C, child);
+        put(&mut bytes, 0x74, start);
+        put(&mut bytes, 0x78, u32::try_from(size).unwrap());
+        bytes
+    };
+    let first = u32::try_from(first_data).unwrap();
+    let mut directory = if small {
+        let mut directory = entry("Root Entry", 5, 1, first, data.len());
+        directory.extend(entry(name, 2, 0xFFFF_FFFF, 0, stream.len()));
+        directory
+    } else {
+        let mut directory = entry("Root Entry", 5, 1, END, 0);
+        directory.extend(entry(name, 2, 0xFFFF_FFFF, first, stream.len()));
+        directory
+    };
+    directory.resize(SECTOR, 0);
+    let mut file = header;
+    file.extend(fat.iter().flat_map(|word| word.to_le_bytes()));
+    file.extend(directory);
+    if small {
+        let mut mini_fat: Vec<u32> =
+            (1..data.len() / 64).map(|next| u32::try_from(next).unwrap()).collect();
+        mini_fat.push(END);
+        mini_fat.resize(SECTOR / 4, 0xFFFF_FFFF);
+        file.extend(mini_fat.iter().flat_map(|word| word.to_le_bytes()));
+    }
+    file.extend(pad(&data, SECTOR));
+    file
+}

data/ext/imprimatur_native/ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imprimatur_native"
-version = "0.1.0"
+version = "0.2.0"
 description = "Ruby bindings for the imprimatur crate"
 publish = false
 edition.workspace = true
@@ -15,7 +15,7 @@ crate-type = ["cdylib"]
 workspace = true
 
 [dependencies]
-imprimatur = { workspace = true, features = ["json"] }
+imprimatur = { workspace = true, features = ["archive", "json"] }
 serde_json.workspace = true
 magnus.workspace = true
 rb-sys.workspace = true

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

@@ -0,0 +1,121 @@
+//! `Imprimatur::Native::ZipWriter` and `ZipReader`: zip archives of any
+//! files, compressed and read without the GVL.
+
+use std::cell::RefCell;
+use std::fs::File;
+
+use imprimatur::archive::{Archive, Writer};
+use magnus::{Error, RString, Ruby};
+
+use crate::blocking::without_gvl;
+use crate::{OrRaise, borrow};
+
+#[magnus::wrap(class = "Imprimatur::Native::ZipWriter", free_immediately, size)]
+pub struct ZipWriter(RefCell<Option<Writer<File>>>);
+
+fn finished(ruby: &Ruby) -> Error {
+    Error::new(ruby.exception_runtime_error(), "the archive is finished")
+}
+
+#[expect(clippy::needless_pass_by_value, reason = "magnus passes Ruby arguments as owned values")]
+impl ZipWriter {
+    /// A new archive at `path`.
+    pub fn new(ruby: &Ruby, path: String) -> Result<Self, Error> {
+        Ok(Self(RefCell::new(Some(Writer::create(path).or_raise(ruby)?))))
+    }
+
+    /// Adds the file at `source` as `name`, streamed.
+    pub fn add_file(
+        ruby: &Ruby,
+        rb_self: &Self,
+        name: String,
+        source: String,
+        comment: Option<String>,
+    ) -> Result<(), Error> {
+        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_file(&name, &source, comment.as_deref()))?.or_raise(ruby)
+    }
+
+    /// Adds `data` as `name`.
+    pub fn add(
+        ruby: &Ruby,
+        rb_self: &Self,
+        name: String,
+        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 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)
+    }
+
+    /// The archive's own comment.
+    pub fn set_comment(ruby: &Ruby, rb_self: &Self, comment: String) -> Result<(), Error> {
+        let mut slot = borrow(ruby, &rb_self.0, "zip writer")?;
+        slot.as_mut().ok_or_else(|| finished(ruby))?.set_comment(&comment).or_raise(ruby)
+    }
+
+    /// Writes the archive's directory; the writer takes no more entries.
+    pub fn finish(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        let writer =
+            borrow(ruby, &rb_self.0, "zip writer")?.take().ok_or_else(|| finished(ruby))?;
+        without_gvl(ruby, || writer.finish())?.or_raise(ruby).map(drop)
+    }
+}
+
+/// An entry for Ruby: name, size, compressed size, CRC-32, comment.
+type EntryRow = (String, u64, u64, u32, String);
+
+#[magnus::wrap(class = "Imprimatur::Native::ZipReader", free_immediately, size)]
+pub struct ZipReader(RefCell<Archive<File>>);
+
+#[expect(clippy::needless_pass_by_value, reason = "magnus passes Ruby arguments as owned values")]
+impl ZipReader {
+    /// The archive at `path`.
+    pub fn new(ruby: &Ruby, path: String) -> Result<Self, Error> {
+        Ok(Self(RefCell::new(Archive::open(path).or_raise(ruby)?)))
+    }
+
+    pub fn names(ruby: &Ruby, rb_self: &Self) -> Result<Vec<String>, Error> {
+        Ok(borrow(ruby, &rb_self.0, "zip archive")?.names())
+    }
+
+    /// Each entry's name, size, compressed size, CRC-32 and comment.
+    pub fn entries(ruby: &Ruby, rb_self: &Self) -> Result<Vec<EntryRow>, Error> {
+        let entries = borrow(ruby, &rb_self.0, "zip archive")?.entries().or_raise(ruby)?;
+        Ok(entries
+            .into_iter()
+            .map(|entry| {
+                (entry.name, entry.size, entry.compressed_size, entry.crc32, entry.comment)
+            })
+            .collect())
+    }
+
+    /// The entry's bytes, `nil` when there is none.
+    pub fn read(
+        ruby: &Ruby,
+        rb_self: &Self,
+        name: String,
+        limit: u64,
+    ) -> Result<Option<RString>, Error> {
+        let mut archive = borrow(ruby, &rb_self.0, "zip archive")?;
+        let data = without_gvl(ruby, || archive.read(&name, limit))?.or_raise(ruby)?;
+        Ok(data.map(|data| ruby.str_from_slice(&data)))
+    }
+
+    /// Writes the entry to `path`; whether there was one.
+    pub fn extract(
+        ruby: &Ruby,
+        rb_self: &Self,
+        name: String,
+        path: String,
+        limit: u64,
+    ) -> Result<bool, Error> {
+        let mut archive = borrow(ruby, &rb_self.0, "zip archive")?;
+        without_gvl(ruby, || archive.extract(&name, &path, limit))?.or_raise(ruby)
+    }
+}

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

@@ -0,0 +1,63 @@
+//! Work run without the GVL that cannot stop midway (compressing a file):
+//! Ruby's other threads keep running, and an interrupt waits for the end.
+
+use std::ffi::c_void;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+
+use magnus::{Error, Ruby};
+
+/// Runs interrupted before they start are retried this many times.
+pub const MAX_ATTEMPTS: usize = 64;
+
+/// The job, and what it returned (or that it panicked).
+struct Slot<F, T> {
+    job: Option<F>,
+    result: Option<std::thread::Result<T>>,
+}
+
+/// Runs `job` on this thread with the GVL released.
+pub fn without_gvl<F: FnOnce() -> T, T>(ruby: &Ruby, job: F) -> Result<T, Error> {
+    let mut slot = Slot { job: Some(job), result: None };
+    let pointer: *mut Slot<F, T> = &raw mut slot;
+    for _ in 0..MAX_ATTEMPTS {
+        // SAFETY: `slot` outlives the call, which returns once `run` has
+        // finished or never started; `run` touches no Ruby object. Without
+        // an unblocking function the job runs to its end; the `2` variant
+        // raises no pending interrupt across these Rust frames.
+        #[allow(unsafe_code)]
+        unsafe {
+            rb_sys::rb_thread_call_without_gvl2(
+                Some(run::<F, T>),
+                pointer.cast(),
+                None,
+                std::ptr::null_mut(),
+            );
+        }
+        match slot.result.take() {
+            Some(Ok(value)) => return Ok(value),
+            Some(Err(_)) => {
+                return Err(Error::new(
+                    ruby.exception_runtime_error(),
+                    "imprimatur failed on this archive",
+                ));
+            }
+            // An interrupt was pending, so the job never started: let Ruby
+            // handle it (it may raise), then start.
+            None => ruby.thread_check_ints()?,
+        }
+    }
+    Err(Error::new(ruby.exception_runtime_error(), "interrupted before it could start"))
+}
+
+/// The job itself, without the GVL; a panic becomes an error, not an
+/// abort at this C boundary.
+#[allow(unsafe_code)]
+unsafe extern "C" fn run<F: FnOnce() -> T, T>(data: *mut c_void) -> *mut c_void {
+    // SAFETY: `data` is the `Slot` without_gvl passed, alive and not
+    // otherwise borrowed until this returns.
+    let slot = unsafe { &mut *data.cast::<Slot<F, T>>() };
+    if let Some(job) = slot.job.take() {
+        slot.result = Some(catch_unwind(AssertUnwindSafe(job)));
+    }
+    std::ptr::null_mut()
+}

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

@@ -3,6 +3,8 @@
 //! [`imprimatur::xlsx::Format`]. The Ruby DSL in `lib/imprimatur/xlsx.rb`
 //! drives them; sheets cross as indices.
 
+mod archive;
+mod blocking;
 mod convert;
 mod document;
 mod read;
@@ -284,6 +286,18 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     native.define_singleton_method("markdown", function!(read::markdown_native, 4))?;
     native.define_singleton_method("content", function!(read::content_native, 4))?;
     native.define_singleton_method("images", function!(read::images_native, 4))?;
+    let zip_writer = native.define_class("ZipWriter", ruby.class_object())?;
+    zip_writer.define_singleton_method("new", function!(archive::ZipWriter::new, 1))?;
+    zip_writer.define_method("add_file", method!(archive::ZipWriter::add_file, 3))?;
+    zip_writer.define_method("add", method!(archive::ZipWriter::add, 3))?;
+    zip_writer.define_method("comment=", method!(archive::ZipWriter::set_comment, 1))?;
+    zip_writer.define_method("finish", method!(archive::ZipWriter::finish, 0))?;
+    let zip_reader = native.define_class("ZipReader", ruby.class_object())?;
+    zip_reader.define_singleton_method("new", function!(archive::ZipReader::new, 1))?;
+    zip_reader.define_method("names", method!(archive::ZipReader::names, 0))?;
+    zip_reader.define_method("entries", method!(archive::ZipReader::entries, 0))?;
+    zip_reader.define_method("read", method!(archive::ZipReader::read, 2))?;
+    zip_reader.define_method("extract", method!(archive::ZipReader::extract, 3))?;
     document::define(ruby, native)?;
     let workbook = native.define_class("Workbook", ruby.class_object())?;
     workbook.define_singleton_method("new", function!(NativeWorkbook::new, 0))?;

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

@@ -13,11 +13,9 @@ use imprimatur::read::{Limits, content, images, json, markdown};
 use magnus::{Error, IntoValue, RArray, RString, Ruby};
 use serde_json::Value as Json;
 
+use crate::blocking::MAX_ATTEMPTS;
 use crate::{argument_error, domain_error};
 
-/// Reads interrupted without anything to raise are retried this many times.
-const MAX_ATTEMPTS: usize = 64;
-
 /// A read of a document's bytes within limits, run without the GVL.
 type Job<T> = fn(&[u8], &Limits) -> imprimatur::Result<T>;
 

data/lib/imprimatur/error.rb

@@ -9,11 +9,12 @@ module Imprimatur
   # A PDF without a text layer: its pages are images (scans), which need OCR.
   class NoTextLayer < Error; end
 
-  # A PDF encrypted with a user password; only an empty one is tried.
+  # A PDF encrypted with a user password (only an empty one is tried), or
+  # an encrypted legacy +.xls+.
   class PasswordRequired < Error; end
 
-  # A format {Imprimatur.markdown} does not read: legacy +.xls+ and +.doc+,
-  # binary +.xlsb+, presentations, anything not a PDF, XLSX or DOCX.
+  # A format {Imprimatur.markdown} does not read: legacy +.doc+, binary
+  # +.xlsb+, presentations, anything not a PDF, XLSX, XLS, ODS or DOCX.
   class UnsupportedDocument < Error; end
 
   # The read hit one of its limits (size, decompressed size, nesting, time),

data/lib/imprimatur/reader.rb

@@ -14,7 +14,7 @@ module Imprimatur
   module Reader
     # File signatures a document's bytes start with; a String that starts
     # with neither is taken for a path.
-    SIGNATURES = ["%PDF-".b, "PK\x03\x04".b, "PK\x05\x06".b].freeze
+    SIGNATURES = ["%PDF-".b, "PK\x03\x04".b, "PK\x05\x06".b, "\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1".b].freeze
     private_constant :SIGNATURES
 
     # @see Imprimatur.markdown

data/lib/imprimatur/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Imprimatur
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/imprimatur/zip.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Imprimatur
+  # Zip archives of any files: entries written with their modification times
+  # and comments (ZIP64 when large), read one at a time within a size limit.
+  # Compressing and reading run without the GVL.
+  #
+  #   Imprimatur::Zip.write('export.zip') do |zip|
+  #     zip.add_file('contracts/0contract.pdf', '/tmp/contract.pdf', comment: 'Contract')
+  #     zip.add('manifest.json', JSON.generate(manifest))
+  #   end
+  #
+  #   Imprimatur::Zip.open('geolite.zip') do |zip|
+  #     zip.read(zip.glob('**/*-Locations-en.csv').first)
+  #   end
+  module Zip
+    # Bytes an entry may hold once decompressed by default: 1 GiB.
+    MAX_ENTRY_BYTES = 1024**3
+
+    # An entry added to an archive being written.
+    Added = Data.define(:name, :comment)
+
+    # An entry of an archive being read, as its directory states it.
+    Entry = Data.define(:name, :size, :compressed_size, :crc32, :comment)
+
+    # Writes an archive at +path+, the block adding its entries. On an
+    # error, the partial file is removed.
+    #
+    # @yieldparam zip [Writer]
+    # @return the path
+    def self.write(path)
+      writer = Writer.new(path)
+      yield writer
+      writer.finish
+      path
+    rescue Exception # any failure, an interrupt included: the partial file goes, then the error
+      FileUtils.rm_f(path.to_s) if writer
+      raise
+    end
+
+    # The archive at +path+.
+    #
+    # @yieldparam zip [Reader] when a block is given
+    # @return [Reader, Object] the reader, or what the block returns
+    # @raise [Errno::ENOENT] when there is no such file
+    # @raise [Error] when it is no zip
+    def self.open(path)
+      reader = Reader.new(path)
+      block_given? ? yield(reader) : reader
+    end
+
+    # Adds entries to an archive being written; see {Zip.write}.
+    class Writer
+      # @return [Array<Added>] the entries added so far, in order
+      attr_reader :entries
+
+      def initialize(path)
+        @native = Native::ZipWriter.new(path.to_s)
+        @entries = []
+      end
+
+      # Adds the file at +source+ as +name+, streamed from disk, with its
+      # modification time.
+      def add_file(name, source, comment: nil)
+        @native.add_file(name.to_s, source.to_s, comment&.to_s)
+        @entries << Added.new(name: name.to_s, comment: comment&.to_s)
+        self
+      end
+
+      # Adds +data+ as +name+, dated now.
+      def add(name, data, comment: nil)
+        @native.add(name.to_s, data.to_s.b, comment&.to_s)
+        @entries << Added.new(name: name.to_s, comment: comment&.to_s)
+        self
+      end
+
+      # The archive's own comment, shown by most zip tools.
+      def comment=(comment)
+        @native.comment = comment.to_s
+      end
+
+      # @api private
+      def finish = @native.finish
+    end
+
+    # An archive's entries, by name; see {Zip.open}.
+    class Reader
+      # @return [Array<String>] the entries' names, in the archive's order
+      attr_reader :names
+
+      def initialize(path)
+        raise Errno::ENOENT, path.to_s unless File.file?(path.to_s)
+
+        @native = Native::ZipReader.new(path.to_s)
+        @names = @native.names.freeze
+      end
+
+      # Each entry's name, sizes, CRC-32 and comment, nothing decompressed.
+      #
+      # @return [Array<Entry>]
+      def entries
+        @native.entries.map { |row| Entry.new(*row) }
+      end
+
+      # The names matching a shell pattern, +**/+ spanning folders.
+      def glob(pattern) = names.select { File.fnmatch?(pattern, it, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+
+      # The entry's bytes, binary.
+      #
+      # @raise [KeyError] for an entry the archive does not have
+      # @raise [LimitExceeded] when it holds more than +max_bytes+
+      def read(name, max_bytes: MAX_ENTRY_BYTES)
+        @native.read(name.to_s, Integer(max_bytes)) or raise KeyError, "no entry #{name} in the archive"
+      end
+
+      # Writes the entry to +path+, streamed; returns +path+.
+      #
+      # @raise (see #read)
+      def extract(name, path, max_bytes: MAX_ENTRY_BYTES)
+        @native.extract(name.to_s, path.to_s, Integer(max_bytes)) or raise KeyError, "no entry #{name} in the archive"
+        path
+      end
+    end
+  end
+end

data/lib/imprimatur.rb

@@ -9,6 +9,7 @@ require_relative 'imprimatur/validation'
 require_relative 'imprimatur/xlsx'
 require_relative 'imprimatur/document'
 require_relative 'imprimatur/reader'
+require_relative 'imprimatur/zip'
 
 # Document authoring with a native core: XLSX workbooks, and PDF and DOCX from
 # one document model.
@@ -46,7 +47,7 @@ module Imprimatur
     # As {.pdf}, rendered as DOCX.
     def docx(path = nil, **options, &) = Document.build(:docx, path, **options, &)
 
-    # A PDF, XLSX or DOCX as Markdown: a PDF's text layer (headings by font
+    # A PDF, workbook (XLSX, XLS, ODS) or DOCX as Markdown: a PDF's text layer (headings by font
     # size, running headers and footers left out, pages marked with
     # +<!-- page N -->+), each sheet of a workbook as a table, a Word
     # document's headings, lists, emphasis, links and tables. The format is
@@ -67,7 +68,7 @@ module Imprimatur
     # @return [String] Markdown, UTF-8
     # @raise [NoTextLayer] a PDF of scanned pages: run OCR instead
     # @raise [PasswordRequired] a PDF that needs a password to open
-    # @raise [UnsupportedDocument] not a PDF, XLSX or DOCX
+    # @raise [UnsupportedDocument] not a PDF, XLSX, XLS, ODS or DOCX
     # @raise [LimitExceeded] the document is too large, too deep or too slow
     # @raise [Error] a damaged document
     def markdown(document, ...) = Reader.markdown(document, ...)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: imprimatur
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -25,7 +25,8 @@ dependencies:
         version: 0.9.130
 description: 'A Ruby DSL over a native core that writes Excel workbooks, and PDF and
   Word documents from one model, with its own XML, zip and PDF writers: no third-party
-  format stack. Precompiled for Linux, macOS and FreeBSD; CRuby only.'
+  format stack. It reads PDF, XLSX, XLS, ODS and DOCX back: as Markdown, as typed
+  structure, and their images. Precompiled for Linux, macOS and FreeBSD; CRuby only.'
 email:
 - terminale@gmail.com
 executables: []
@@ -50,6 +51,7 @@ files:
 - ext/imprimatur_native/core/Cargo.toml
 - ext/imprimatur_native/core/LICENSE
 - ext/imprimatur_native/core/README.md
+- ext/imprimatur_native/core/src/archive.rs
 - ext/imprimatur_native/core/src/doc.rs
 - ext/imprimatur_native/core/src/doc/paragraph.rs
 - ext/imprimatur_native/core/src/doc/table.rs
@@ -73,6 +75,9 @@ files:
 - ext/imprimatur_native/core/src/read/inflate.rs
 - ext/imprimatur_native/core/src/read/json.rs
 - ext/imprimatur_native/core/src/read/markdown.rs
+- ext/imprimatur_native/core/src/read/numbers.rs
+- ext/imprimatur_native/core/src/read/ods.rs
+- ext/imprimatur_native/core/src/read/ole.rs
 - ext/imprimatur_native/core/src/read/package.rs
 - ext/imprimatur_native/core/src/read/pdf.rs
 - ext/imprimatur_native/core/src/read/pdf/cmap.rs
@@ -92,8 +97,9 @@ files:
 - ext/imprimatur_native/core/src/read/pdf/object/name.rs
 - ext/imprimatur_native/core/src/read/pdf/xref.rs
 - ext/imprimatur_native/core/src/read/span.rs
+- ext/imprimatur_native/core/src/read/xls.rs
+- ext/imprimatur_native/core/src/read/xls/strings.rs
 - ext/imprimatur_native/core/src/read/xlsx.rs
-- ext/imprimatur_native/core/src/read/xlsx/numbers.rs
 - ext/imprimatur_native/core/src/style.rs
 - ext/imprimatur_native/core/src/test_support.rs
 - ext/imprimatur_native/core/src/xlsx.rs
@@ -113,6 +119,8 @@ files:
 - ext/imprimatur_native/core/src/zip/reader.rs
 - ext/imprimatur_native/extconf.rb
 - ext/imprimatur_native/ffi/Cargo.toml
+- ext/imprimatur_native/ffi/src/archive.rs
+- ext/imprimatur_native/ffi/src/blocking.rs
 - ext/imprimatur_native/ffi/src/convert.rs
 - ext/imprimatur_native/ffi/src/document.rs
 - ext/imprimatur_native/ffi/src/lib.rs
@@ -129,6 +137,7 @@ files:
 - lib/imprimatur/validation.rb
 - lib/imprimatur/version.rb
 - lib/imprimatur/xlsx.rb
+- lib/imprimatur/zip.rb
 homepage: https://github.com/seuros/imprimatur
 licenses:
 - BSD-3-Clause
@@ -153,5 +162,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.20
 specification_version: 4
-summary: XLSX, PDF and DOCX authoring with a Ruby DSL. Let it be printed.
+summary: XLSX, PDF and DOCX authoring, and office documents read back. Let it be printed.
 test_files: []