anydoc 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad2ef90ad06d780f64b4d8ffc6e7881654ede6984587679b90b746450ec6c509
+  data.tar.gz: 9df934da5ab5c6110ced6e23eb63b6f8d2972fe685460b39d83382abc20deb68
+SHA512:
+  metadata.gz: 22e930d99a40fb5117befacf5e9e4af541c1696eb8eb925a6d92e02a13e46324253e4f65edfd4473f3df7f0fc5e3e1c7452646b80791d46fc85b688a407de8c4
+  data.tar.gz: 78f1a749bbab09c9c68f9d1e08f6d8aac41c3ca4d2b5ec6e9ffb72359a5e5bde6dece98b2be284f0fbfa2269c218e76b018b1f51f6a345fd879f9bfdde00b328

data/Cargo.toml

@@ -0,0 +1,11 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/anydoc"]
+resolver = "2"
+
+[profile.release]
+lto = "thin"
+strip = "symbols"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Nick Pezza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# anydoc
+
+[![Gem Version](https://img.shields.io/gem/v/anydoc.svg)](https://rubygems.org/gems/anydoc)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/firecrawl/anydoc/blob/main/LICENSE)
+
+Convert Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, CSV, and PDF files into clean GitHub-Flavored Markdown. Ruby bindings for the [anydoc](https://github.com/firecrawl/anydoc) Rust crate, built by [Firecrawl](https://firecrawl.dev). Also available as a hosted API through [Firecrawl Parse](https://firecrawl.dev/parse), which adds OCR for scanned pages anydoc cannot read on its own.
+
+Every format parses into one shared document model and renders through a single Markdown serializer, so headings, tables, lists, and footnotes come out consistently. Conversion runs without holding Ruby's global VM lock, and RBS signatures ship with the gem.
+
+```bash
+gem install anydoc
+```
+
+Or add it with Bundler:
+
+```bash
+bundle add anydoc
+```
+
+## Supported formats
+
+| Format           | Extensions                                                 |
+| ---------------- | ---------------------------------------------------------- |
+| Word             | `.doc`, `.docx`, `.docm`                                   |
+| PowerPoint       | `.ppt`, `.pps`, `.pot`, `.pptx`, `.pptm`, `.ppsx`, `.ppsm` |
+| Excel            | `.xls`, `.xlsx`, `.xlsm`, `.xlsb`                          |
+| OpenDocument     | `.odt`, `.ods`, `.odp`                                     |
+| Rich Text Format | `.rtf`                                                     |
+| EPUB             | `.epub`                                                    |
+| CSV              | `.csv`                                                     |
+| PDF              | `.pdf`                                                     |
+
+## Usage
+
+```ruby
+require "anydoc"
+
+# From a file path. Pathname and other #to_path objects are accepted.
+markdown = Anydoc.to_markdown("report.docx")
+
+# From bytes, with the format detected from the content.
+markdown = Anydoc.to_markdown_bytes(data)
+
+# Signature-less formats such as CSV need an explicit format.
+markdown = Anydoc.to_markdown_bytes(data, :csv)
+
+# Or stop at the immutable document model, which carries embedded assets.
+document = Anydoc.to_document(data)
+document.blocks
+document.notes
+document.assets
+```
+
+## Format detection
+
+The format is read from the file content using the marker designated by its specification: the PDF header, RTF open group, OLE stream names, or ZIP package metadata. CSV has no signature, so detection returns `nil`; its extension or an explicit format names it instead.
+
+```ruby
+Anydoc.format_from_bytes(data)              # => :docx, or nil
+Anydoc.format_from_extension(".pptm")       # => :pptx
+Anydoc.format_from_path("report.odt")       # => :odt
+```
+
+## Images and embedded objects
+
+Markdown cannot embed bytes. Embedded images render as alt text while their binary strings remain in `document.assets`, tagged with a media type and the package part they came from. Images with external URLs render as ordinary Markdown images.
+
+PDF conversion emits Markdown directly and does not have a document-model form; use `Anydoc.to_markdown` or `Anydoc.to_markdown_bytes` for PDFs.
+
+## Development
+
+```bash
+bin/setup
+bundle exec rake compile test
+```
+
+## License
+
+[MIT](https://github.com/firecrawl/anydoc/blob/main/LICENSE)

data/Rakefile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+require "tmpdir"
+
+RuboCop::RakeTask.new do |task|
+  task.options = ["--cache-root", File.join(File.realpath(Dir.tmpdir), "anydoc-rubocop-cache")]
+end
+
+require "rb_sys/extensiontask"
+
+task build: :compile
+
+GEMSPEC = Gem::Specification.load("anydoc.gemspec")
+
+RbSys::ExtensionTask.new("anydoc", GEMSPEC) do |ext|
+  ext.lib_dir = "lib/anydoc"
+end
+
+task default: %i[compile test rubocop]

data/ext/anydoc/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "anydoc"
+version = "0.1.3-ruby.0"
+edition = "2024"
+authors = ["Nick Pezza <pezza@hey.com>"]
+license = "MIT"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+anydoc-core = { package = "anydoc", version = "=0.1.3" }
+magnus = "0.8.2"
+rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"] }
+
+[build-dependencies]
+rb-sys-env = "0.2.2"
+
+[dev-dependencies]
+rb-sys-test-helpers = { version = "0.2.2" }

data/ext/anydoc/build.rs

@@ -0,0 +1,5 @@
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let _ = rb_sys_env::activate()?;
+
+    Ok(())
+}

data/ext/anydoc/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("anydoc/anydoc")

data/ext/anydoc/src/document.rs

@@ -0,0 +1,187 @@
+//! The document model, converted eagerly into immutable Ruby `Data` objects.
+
+use anydoc_core::model;
+use magnus::{Error, RArray, RClass, RModule, RString, Ruby, Value, prelude::*};
+
+fn class(ruby: &Ruby, name: &str) -> Result<RClass, Error> {
+    let module: RModule = ruby.class_object().const_get("Anydoc")?;
+    module.const_get(name)
+}
+
+fn array(ruby: &Ruby, values: impl Iterator<Item = Result<Value, Error>>) -> Result<RArray, Error> {
+    let values = values.collect::<Result<Vec<_>, _>>()?;
+    Ok(ruby.ary_new_from_values(&values))
+}
+
+fn blocks(ruby: &Ruby, items: Vec<model::Block>) -> Result<RArray, Error> {
+    array(ruby, items.into_iter().map(|item| block(ruby, item)))
+}
+
+fn inlines(ruby: &Ruby, items: Vec<model::Inline>) -> Result<RArray, Error> {
+    array(ruby, items.into_iter().map(|item| inline(ruby, item)))
+}
+
+fn block(ruby: &Ruby, block: model::Block) -> Result<Value, Error> {
+    let (kind, level, anchor, content, list, table, inner, lang, text) = match block {
+        model::Block::Heading { level, anchor, content } => (
+            "heading",
+            Some(level),
+            anchor,
+            Some(inlines(ruby, content)?),
+            None,
+            None,
+            None,
+            None,
+            None,
+        ),
+        model::Block::Paragraph(content) => {
+            ("paragraph", None, None, Some(inlines(ruby, content)?), None, None, None, None, None)
+        }
+        model::Block::List(value) => {
+            ("list", None, None, None, Some(list_value(ruby, value)?), None, None, None, None)
+        }
+        model::Block::Table(value) => {
+            ("table", None, None, None, None, Some(table_value(ruby, value)?), None, None, None)
+        }
+        model::Block::BlockQuote(value) => {
+            ("block_quote", None, None, None, None, None, Some(blocks(ruby, value)?), None, None)
+        }
+        model::Block::CodeBlock { lang, text } => {
+            ("code_block", None, None, None, None, None, None, lang, Some(text))
+        }
+        model::Block::Rule => ("rule", None, None, None, None, None, None, None, None),
+    };
+    class(ruby, "Block")?
+        .funcall("new", (kind, level, anchor, content, list, table, inner, lang, text))
+}
+
+fn inline(ruby: &Ruby, inline: model::Inline) -> Result<Value, Error> {
+    let (kind, text, style, content, target, alt, source, anchor, note_id) = match inline {
+        model::Inline::Text { text, style } => (
+            "text",
+            Some(text),
+            Some(style_value(ruby, style)?),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        ),
+        model::Inline::Link { content, target } => (
+            "link",
+            None,
+            None,
+            Some(inlines(ruby, content)?),
+            Some(link_target(ruby, target)?),
+            None,
+            None,
+            None,
+            None,
+        ),
+        model::Inline::Image { alt, source } => (
+            "image",
+            None,
+            None,
+            None,
+            None,
+            Some(alt),
+            Some(image_source(ruby, source)?),
+            None,
+            None,
+        ),
+        model::Inline::Anchor(id) => ("anchor", None, None, None, None, None, None, Some(id), None),
+        model::Inline::NoteRef(id) => {
+            ("note_ref", None, None, None, None, None, None, None, Some(id))
+        }
+        model::Inline::LineBreak => ("line_break", None, None, None, None, None, None, None, None),
+    };
+    class(ruby, "Inline")?
+        .funcall("new", (kind, text, style, content, target, alt, source, anchor, note_id))
+}
+
+fn style_value(ruby: &Ruby, style: model::Style) -> Result<Value, Error> {
+    class(ruby, "Style")?.funcall("new", (style.bold, style.italic, style.strike, style.code))
+}
+
+fn link_target(ruby: &Ruby, target: model::LinkTarget) -> Result<Value, Error> {
+    let (kind, value) = match target {
+        model::LinkTarget::External(value) => ("external", value),
+        model::LinkTarget::Relative(value) => ("relative", value),
+        model::LinkTarget::Anchor(value) => ("anchor", value),
+    };
+    class(ruby, "LinkTarget")?.funcall("new", (kind, value))
+}
+
+fn image_source(ruby: &Ruby, source: model::ImageSource) -> Result<Value, Error> {
+    let (kind, url, asset_id) = match source {
+        model::ImageSource::External(url) => ("external", Some(url), None),
+        model::ImageSource::Asset(id) => ("asset", None, Some(id.0)),
+        model::ImageSource::Unavailable => ("unavailable", None, None),
+    };
+    class(ruby, "ImageSource")?.funcall("new", (kind, url, asset_id))
+}
+
+fn list_value(ruby: &Ruby, list: model::List) -> Result<Value, Error> {
+    let marker = match list.marker {
+        model::MarkerKind::Bullet => "bullet",
+        model::MarkerKind::Decimal => "decimal",
+        model::MarkerKind::LowerAlpha => "lower_alpha",
+        model::MarkerKind::UpperAlpha => "upper_alpha",
+        model::MarkerKind::LowerRoman => "lower_roman",
+        model::MarkerKind::UpperRoman => "upper_roman",
+    };
+    let items = array(ruby, list.items.into_iter().map(|item| list_item(ruby, item)))?;
+    class(ruby, "List")?.funcall("new", (marker, list.start, items))
+}
+
+fn list_item(ruby: &Ruby, item: model::ListItem) -> Result<Value, Error> {
+    class(ruby, "ListItem")?
+        .funcall("new", (blocks(ruby, item.blocks)?, item.checked, item.marker_label))
+}
+
+fn table_value(ruby: &Ruby, table: model::Table) -> Result<Value, Error> {
+    let rows = table.grid.into_iter().map(|row| {
+        let row = array(ruby, row.into_iter().map(|slot| cell_slot(ruby, slot)))?;
+        Ok(row.as_value())
+    });
+    let grid = array(ruby, rows)?;
+    let kind = match table.kind {
+        model::TableKind::Data => "data",
+        model::TableKind::Layout => "layout",
+    };
+    class(ruby, "Table")?.funcall("new", (grid, table.header_rows, kind))
+}
+
+fn cell_slot(ruby: &Ruby, slot: model::CellSlot) -> Result<Value, Error> {
+    let (kind, cell, origin_row, origin_col) = match slot {
+        model::CellSlot::Origin(value) => ("origin", Some(cell(ruby, value)?), None, None),
+        model::CellSlot::Covered { origin_row, origin_col } => {
+            ("covered", None, Some(origin_row), Some(origin_col))
+        }
+    };
+    class(ruby, "CellSlot")?.funcall("new", (kind, cell, origin_row, origin_col))
+}
+
+fn cell(ruby: &Ruby, cell: model::Cell) -> Result<Value, Error> {
+    class(ruby, "Cell")?.funcall("new", (blocks(ruby, cell.blocks)?, cell.col_span, cell.row_span))
+}
+
+fn note(ruby: &Ruby, note: model::Note) -> Result<Value, Error> {
+    let kind = match note.kind {
+        model::NoteKind::Footnote => "footnote",
+        model::NoteKind::Endnote => "endnote",
+    };
+    class(ruby, "Note")?.funcall("new", (note.id, kind, blocks(ruby, note.blocks)?))
+}
+
+fn asset(ruby: &Ruby, asset: model::Asset) -> Result<Value, Error> {
+    let data: RString = ruby.str_from_slice(&asset.bytes);
+    class(ruby, "Asset")?.funcall("new", (asset.id.0, asset.media_type, asset.origin_part, data))
+}
+
+pub fn document(ruby: &Ruby, document: model::Document) -> Result<Value, Error> {
+    let notes = array(ruby, document.notes.into_iter().map(|value| note(ruby, value)))?;
+    let assets = array(ruby, document.assets.into_iter().map(|value| asset(ruby, value)))?;
+    class(ruby, "Document")?.funcall("new", (blocks(ruby, document.blocks)?, notes, assets))
+}

data/ext/anydoc/src/lib.rs

@@ -0,0 +1,147 @@
+//! Ruby bindings for anydoc.
+
+use magnus::{
+    Error, Exception, RString, Ruby, Value, exception::ExceptionClass, function, prelude::*,
+};
+use std::{ffi::c_void, panic::AssertUnwindSafe, ptr};
+
+mod document;
+
+const FORMATS: [(&str, anydoc_core::Format); 12] = [
+    ("doc", anydoc_core::Format::Doc),
+    ("docx", anydoc_core::Format::Docx),
+    ("odt", anydoc_core::Format::Odt),
+    ("pdf", anydoc_core::Format::Pdf),
+    ("ppt", anydoc_core::Format::Ppt),
+    ("pptx", anydoc_core::Format::Pptx),
+    ("rtf", anydoc_core::Format::Rtf),
+    ("epub", anydoc_core::Format::Epub),
+    ("xlsx", anydoc_core::Format::Excel),
+    ("ods", anydoc_core::Format::Ods),
+    ("odp", anydoc_core::Format::Odp),
+    ("csv", anydoc_core::Format::Csv),
+];
+
+fn parse_format(ruby: &Ruby, name: &str) -> Result<anydoc_core::Format, Error> {
+    FORMATS.iter().find(|(candidate, _)| *candidate == name).map(|(_, format)| *format).ok_or_else(
+        || {
+            let names = FORMATS.iter().map(|(name, _)| *name).collect::<Vec<_>>().join(", ");
+            Error::new(
+                ruby.exception_arg_error(),
+                format!("unknown format {name:?}; expected one of {names}"),
+            )
+        },
+    )
+}
+
+fn format_name(format: anydoc_core::Format) -> &'static str {
+    FORMATS
+        .iter()
+        .find(|(_, candidate)| *candidate == format)
+        .map(|(name, _)| *name)
+        .expect("every format is named")
+}
+
+fn convert_error(ruby: &Ruby, error: anydoc_core::ConvertError) -> Error {
+    match error {
+        anydoc_core::ConvertError::Io(error) => match error.raw_os_error() {
+            Some(errno) => ruby
+                .exception_system_call_error()
+                .funcall::<_, _, Exception>("new", (error.to_string(), errno))
+                .map(Error::from)
+                .unwrap_or_else(|error| error),
+            None => Error::new(ruby.exception_io_error(), error.to_string()),
+        },
+        other => {
+            let module = ruby.define_module("Anydoc").expect("Anydoc module is defined");
+            let class: ExceptionClass =
+                module.const_get("ConvertError").expect("Anydoc::ConvertError is defined");
+            Error::new(class, other.to_string())
+        }
+    }
+}
+
+fn bytes(data: RString) -> Vec<u8> {
+    // Copy before conversion so Rust never retains a pointer into Ruby's heap.
+    unsafe { data.as_slice() }.to_vec()
+}
+
+/// Run CPU- and I/O-heavy parsing without holding Ruby's global VM lock.
+fn without_gvl<F, T>(function: F) -> T
+where
+    F: FnOnce() -> T + Send,
+    T: Send,
+{
+    struct Call<F, T> {
+        function: Option<F>,
+        result: Option<std::thread::Result<T>>,
+    }
+
+    unsafe extern "C" fn call<F, T>(data: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> T,
+    {
+        let call = unsafe { &mut *data.cast::<Call<F, T>>() };
+        let function = call.function.take().expect("without_gvl callback runs once");
+        call.result = Some(std::panic::catch_unwind(AssertUnwindSafe(function)));
+        ptr::null_mut()
+    }
+
+    let mut state = Call { function: Some(function), result: None };
+    unsafe {
+        rb_sys::rb_thread_call_without_gvl(
+            Some(call::<F, T>),
+            ptr::from_mut(&mut state).cast(),
+            None,
+            ptr::null_mut(),
+        );
+    }
+    match state.result.expect("without_gvl callback completed") {
+        Ok(value) => value,
+        Err(panic) => std::panic::resume_unwind(panic),
+    }
+}
+
+fn format_from_bytes(data: RString) -> Option<&'static str> {
+    anydoc_core::Format::from_bytes(&bytes(data)).map(format_name)
+}
+
+fn format_from_extension(extension: String) -> Option<&'static str> {
+    anydoc_core::Format::from_extension(extension.trim_start_matches('.')).map(format_name)
+}
+
+fn format_from_path(path: String) -> Option<&'static str> {
+    anydoc_core::Format::from_path(std::path::Path::new(&path)).map(format_name)
+}
+
+fn to_markdown(ruby: &Ruby, path: String) -> Result<String, Error> {
+    without_gvl(move || anydoc_core::to_markdown(path)).map_err(|error| convert_error(ruby, error))
+}
+
+fn to_markdown_bytes(ruby: &Ruby, data: RString, format: Option<String>) -> Result<String, Error> {
+    let format = format.as_deref().map(|name| parse_format(ruby, name)).transpose()?;
+    let data = bytes(data);
+    without_gvl(move || anydoc_core::to_markdown_bytes(&data, format))
+        .map_err(|error| convert_error(ruby, error))
+}
+
+fn to_document(ruby: &Ruby, data: RString, format: Option<String>) -> Result<Value, Error> {
+    let format = format.as_deref().map(|name| parse_format(ruby, name)).transpose()?;
+    let data = bytes(data);
+    let parsed = without_gvl(move || anydoc_core::to_document(&data, format))
+        .map_err(|error| convert_error(ruby, error))?;
+    document::document(ruby, parsed)
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Anydoc")?;
+    module.define_singleton_method("_format_from_bytes", function!(format_from_bytes, 1))?;
+    module
+        .define_singleton_method("_format_from_extension", function!(format_from_extension, 1))?;
+    module.define_singleton_method("_format_from_path", function!(format_from_path, 1))?;
+    module.define_singleton_method("_to_markdown", function!(to_markdown, 1))?;
+    module.define_singleton_method("_to_markdown_bytes", function!(to_markdown_bytes, 2))?;
+    module.define_singleton_method("_to_document", function!(to_document, 2))?;
+    Ok(())
+}

data/lib/anydoc/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Anydoc
+  VERSION = "0.1.3"
+end

data/lib/anydoc.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "anydoc/version"
+
+module Anydoc
+  class Error < StandardError; end
+
+  # Raised when an input can be read, but meaningful conversion is impossible.
+  class ConvertError < Error; end
+
+  Document = Data.define(:blocks, :notes, :assets)
+  Block = Data.define(:kind, :level, :anchor, :content, :list, :table, :blocks, :lang, :text)
+  Inline = Data.define(:kind, :text, :style, :content, :target, :alt, :source, :anchor, :note_id)
+  Style = Data.define(:bold, :italic, :strike, :code)
+  LinkTarget = Data.define(:kind, :value)
+  ImageSource = Data.define(:kind, :url, :asset_id)
+  List = Data.define(:marker, :start, :items)
+  ListItem = Data.define(:blocks, :checked, :marker_label)
+  Table = Data.define(:grid, :header_rows, :kind)
+  CellSlot = Data.define(:kind, :cell, :origin_row, :origin_col)
+  Cell = Data.define(:blocks, :col_span, :row_span)
+  Note = Data.define(:id, :kind, :blocks)
+  Asset = Data.define(:id, :media_type, :origin_part, :data)
+end
+
+require "anydoc/anydoc"
+
+module Anydoc
+  FORMATS = %i[doc docx odt pdf ppt pptx rtf epub xlsx ods odp csv].freeze
+
+  class << self
+    def format_from_bytes(data)
+      _format_from_bytes(data)&.to_sym
+    end
+
+    def format_from_extension(extension)
+      _format_from_extension(extension)&.to_sym
+    end
+
+    def format_from_path(path)
+      _format_from_path(File.path(path))&.to_sym
+    end
+
+    def to_markdown(path)
+      _to_markdown(File.path(path))
+    end
+
+    def to_markdown_bytes(data, format = nil)
+      _to_markdown_bytes(data, format&.to_s)
+    end
+
+    def to_document(data, format = nil)
+      _to_document(data, format&.to_s)
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: anydoc
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Nick Pezza
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.128
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.128
+description: Ruby bindings for the anydoc Rust document converter.
+email:
+- pezza@hey.com
+executables: []
+extensions:
+- ext/anydoc/extconf.rb
+extra_rdoc_files: []
+files:
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/anydoc/Cargo.toml
+- ext/anydoc/build.rs
+- ext/anydoc/extconf.rb
+- ext/anydoc/src/document.rs
+- ext/anydoc/src/lib.rs
+- lib/anydoc.rb
+- lib/anydoc/version.rb
+homepage: https://github.com/firecrawl/anydoc#readme
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/firecrawl/anydoc#readme
+  source_code_uri: https://github.com/firecrawl/anydoc/tree/main/ruby
+  changelog_uri: https://github.com/firecrawl/anydoc/releases
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.15
+specification_version: 4
+summary: Convert documents to GitHub-Flavored Markdown
+test_files: []