anydoc-ruby 0.1.7-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8c4ad832495b176c63d22f5c081121a2dbfa6f44aa672c3bd9a0f024ff7a1287
+  data.tar.gz: 179e918f328a4a766dc082d03be3f39e087c61ab1f8a8877d5b7baf556dbf6ba
+SHA512:
+  metadata.gz: e9361cdb238260b7bef297b97fcfd5722e7a5f607c57fb8b16c6de9f21f2a960b6fa7d8ce3271378a4004e8dd43ff5b4c94c3b9af40191669bdbbff9633f5136
+  data.tar.gz: 81a6725073be6b7cdcc8df3987f57e323e7d9a8992b9a77f80694ad316e4a177b2f0ee93deab9acf884c95a1133b8704325a392bc37b0f5236484e4745bbc451

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sideguide Technologies Inc.
+
+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,149 @@
+# anydoc-ruby
+
+[![Gem](https://img.shields.io/gem/v/anydoc-ruby.svg)](https://rubygems.org/gems/anydoc-ruby)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/honzasterba/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://crates.io/crates/anydoc) Rust crate, which is built by [Firecrawl](https://firecrawl.dev).
+
+Every format parses into one shared document model and renders through a single Markdown serializer, so headings, tables, lists, and footnotes come out the same no matter which format goes in. Conversion releases the GVL, so other threads keep running. RBS signatures ship with the gem.
+
+```bash
+bundle add anydoc-ruby
+```
+
+The gem installs as `anydoc-ruby` and requires as `anydoc`, so a Gemfile entry that Bundler auto-requires needs `gem "anydoc-ruby", require: "anydoc"`. Precompiled native gems cover Linux (glibc and musl), macOS, and Windows on Ruby 3.2+; anywhere else, `gem install` builds the extension from source, which needs a [Rust toolchain](https://rustup.rs).
+
+## 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:
+markdown = Anydoc.to_markdown("report.docx")
+
+# From bytes, with the format detected from the content:
+markdown = Anydoc.to_markdown_bytes(data)
+
+# Or name it, which signature-less formats (CSV) need:
+markdown = Anydoc.to_markdown_bytes(data, format: :csv)
+
+# Or stop at the document model, which also carries embedded assets:
+document = Anydoc.to_document(data)
+```
+
+`to_markdown` takes anything path-like, including a `Pathname`. A format is named with a symbol from `Anydoc::FORMATS`; a string is accepted too.
+
+## Errors
+
+A conversion raises only when no meaningful Markdown could come out of the file. The exception class names what went wrong:
+
+```ruby
+begin
+  Anydoc.to_markdown(path)
+rescue Anydoc::EncryptedError, Anydoc::UnsupportedError => error
+  # No document comes out of these, so record the file and take the next one.
+  unconverted << [path, error.class]
+  nil
+end
+```
+
+| Exception                  | Raised when                                                         |
+| -------------------------- | ------------------------------------------------------------------- |
+| `Anydoc::UnsupportedError`   | Unknown format, or one that cannot be converted (an image-only PDF) |
+| `Anydoc::MalformedError`     | Structurally unusable: no meaningful content could be extracted     |
+| `Anydoc::EncryptedError`     | Encrypted or password-protected                                     |
+| `Anydoc::ResourceLimitError` | Crossed a fixed safety limit (decompression, nesting, node count)   |
+| `Anydoc::MissingPartError`   | A part required for any meaningful output is absent                 |
+| `Errno::*`                   | The file could not be read, from `to_markdown` only                 |
+
+The five conversion failures subclass `Anydoc::ConvertError`, so rescuing that handles all of them at once. `MalformedError#part` and `MissingPartError#part` name the package part at fault, `ResourceLimitError#limit` names the limit crossed as a symbol, and `#message` carries the whole message. A `format:` argument naming no supported format raises `ArgumentError`.
+
+## Format detection
+
+The format is read from the file content, using the marker its specification designates: the PDF header, the RTF open group, OLE stream names, the ZIP package mimetype and content types. CSV has no such marker, so detection returns `nil` for it and the extension, or an explicit format, names it instead.
+
+```ruby
+Anydoc.format_from_bytes(data)         # :docx, or nil when nothing matches
+Anydoc.format_from_extension(".pptm")  # :pptx
+Anydoc.format_from_path("report.odt")  # :odt
+```
+
+## The document model
+
+`Anydoc.to_document` stops at the parsed model instead of rendering it. Every class in it is a `Data`, so instances are frozen, compare by value, answer `to_h`, and destructure in `case/in`:
+
+```ruby
+document = Anydoc.to_document(File.binread("report.docx"))
+
+titles = document.blocks.filter_map do |block|
+  case block
+  in Anydoc::Block[kind: :heading, level: 1, content:]
+    content.filter_map(&:text).join
+  else
+    nil
+  end
+end
+```
+
+Variants are a `kind` symbol plus the members that kind carries; members belonging to other kinds are `nil`. `Document#blocks` holds the body, `Document#notes` the footnote and endnote bodies that `:note_ref` inlines point at, and `Document#assets` the embedded bytes.
+
+PDFs convert straight to Markdown and have no document-model form, so `to_document` raises `UnsupportedError` for them; use `to_markdown_bytes`.
+
+## Images and embedded objects
+
+Markdown cannot embed bytes, so an embedded image renders as its alt text while the bytes stay on `document.assets` as binary strings, tagged with a media type and the part they came from. Images that carry an external URL render as ordinary Markdown images.
+
+```ruby
+document.assets.each do |asset|
+  File.binwrite("asset-#{asset.id}", asset.data) if asset.media_type.start_with?("image/")
+end
+```
+
+Full behavior notes and benchmarks live in the [repository README](https://github.com/honzasterba/anydoc#readme).
+
+## Development
+
+From this directory, with a [Rust toolchain](https://rustup.rs) installed:
+
+```bash
+bundle install
+bundle exec rake        # compile the extension, then run the tests
+bundle exec rake compile
+bundle exec rake test
+```
+
+Inside this repository the extension builds against the crate in the parent directory rather than the published one; `.cargo/config.toml` is what redirects it.
+
+### Packaging
+
+The source gem needs nothing but RubyGems:
+
+```bash
+bundle exec rake build          # pkg/anydoc-ruby-<version>.gem
+```
+
+The precompiled gems are cross-compiled in [rb-sys-dock](https://github.com/oxidize-rb/rb-sys) containers, so they need Docker running. Each one carries an extension per Ruby ABI:
+
+```bash
+bundle exec rake gems:x86_64-linux   # one platform
+bundle exec rake gems:all            # the source gem and all seven platforms
+```
+
+Run these through Rake rather than calling `rb-sys-dock` from this directory: the container mounts the shell's working directory, and the build needs the crate one level above it, so the tasks run the CLI from the repository root with `--directory ruby`. The first build of each platform pulls a multi-gigabyte image.
+
+## License
+
+[MIT](https://github.com/honzasterba/anydoc/blob/main/LICENSE)

data/lib/anydoc/document.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Anydoc
+  # The document model {Anydoc.to_document} returns.
+  #
+  # Every class here is a +Data+, so instances are frozen, compare by value,
+  # answer +to_h+, and destructure in +case/in+:
+  #
+  #   case block
+  #   in Anydoc::Block[kind: :heading, level:, content:]
+  #     ...
+  #   end
+  #
+  # Variants (block kinds, link targets, ...) are a +kind+ symbol plus the
+  # members that kind carries; members belonging to other kinds are +nil+.
+  #
+  # @!parse
+  #   # Only fully resolved content lives in the model: style cascades,
+  #   # numbering, and references are resolved before it is built.
+  class Document < Data.define(
+    # @return [Array<Block>] body content, in reading order.
+    :blocks,
+    # @return [Array<Note>] footnote and endnote bodies, referenced from text
+    #   by a +:note_ref+ inline.
+    :notes,
+    # @return [Array<Asset>] every embedded asset, indexed by its +id+.
+    :assets
+  )
+  end
+
+  # One block-level piece of content.
+  #
+  # @!attribute [r] kind
+  #   @return [Symbol] +:heading+, +:paragraph+, +:list+, +:table+,
+  #     +:block_quote+, +:code_block+, or +:rule+.
+  # @!attribute [r] level
+  #   @return [Integer, nil] heading: 1-6.
+  # @!attribute [r] anchor
+  #   @return [String, nil] heading: stable anchor id, when the document
+  #     targets this heading.
+  # @!attribute [r] content
+  #   @return [Array<Inline>, nil] heading, paragraph.
+  # @!attribute [r] list
+  #   @return [List, nil]
+  # @!attribute [r] table
+  #   @return [Table, nil]
+  # @!attribute [r] blocks
+  #   @return [Array<Block>, nil] block_quote.
+  # @!attribute [r] lang
+  #   @return [String, nil] code_block.
+  # @!attribute [r] text
+  #   @return [String, nil] code_block.
+  class Block < Data.define(
+    :kind, :level, :anchor, :content, :list, :table, :blocks, :lang, :text
+  )
+  end
+
+  # One inline-level piece of content.
+  #
+  # @!attribute [r] kind
+  #   @return [Symbol] +:text+, +:link+, +:image+, +:anchor+ (a zero-width
+  #     marker for an internal link target at this position), +:note_ref+, or
+  #     +:line_break+.
+  # @!attribute [r] text
+  #   @return [String, nil] text.
+  # @!attribute [r] style
+  #   @return [Style, nil] text.
+  # @!attribute [r] content
+  #   @return [Array<Inline>, nil] link.
+  # @!attribute [r] target
+  #   @return [LinkTarget, nil] link.
+  # @!attribute [r] alt
+  #   @return [String, nil] image.
+  # @!attribute [r] source
+  #   @return [ImageSource, nil] image.
+  # @!attribute [r] anchor
+  #   @return [String, nil] anchor: the anchor id.
+  # @!attribute [r] note_id
+  #   @return [String, nil] note_ref: the id of the note in
+  #     {Document#notes}.
+  class Inline < Data.define(
+    :kind, :text, :style, :content, :target, :alt, :source, :anchor, :note_id
+  )
+  end
+
+  # Fully resolved character style.
+  #
+  # @!attribute [r] bold
+  #   @return [Boolean]
+  # @!attribute [r] italic
+  #   @return [Boolean]
+  # @!attribute [r] strike
+  #   @return [Boolean]
+  # @!attribute [r] code
+  #   @return [Boolean] monospace, from a code or teletype character style.
+  class Style < Data.define(:bold, :italic, :strike, :code)
+    # @return [Boolean] whether no toggle is set.
+    def plain? = !(bold || italic || strike || code)
+  end
+
+  # Where a link points.
+  #
+  # @!attribute [r] kind
+  #   @return [Symbol] +:external+ (absolute URL with a scheme), +:relative+
+  #     (scheme-less reference, preserved as written), or +:anchor+ (an
+  #     internal target: a heading anchor or an +:anchor+ inline).
+  # @!attribute [r] value
+  #   @return [String] the URL, relative reference, or anchor id.
+  class LinkTarget < Data.define(:kind, :value)
+  end
+
+  # Where an image's bytes come from.
+  #
+  # @!attribute [r] kind
+  #   @return [Symbol] +:external+ (absolute URL with a scheme), +:asset+
+  #     (embedded, carried in {Document#assets}), or +:unavailable+ (the
+  #     image's part is missing or unreadable and it has no URL, so only the
+  #     alt text remains).
+  # @!attribute [r] url
+  #   @return [String, nil] external.
+  # @!attribute [r] asset_id
+  #   @return [Integer, nil] asset: index into {Document#assets}.
+  class ImageSource < Data.define(:kind, :url, :asset_id)
+  end
+
+  # A list and the marker family the source document used for it.
+  #
+  # @!attribute [r] marker
+  #   @return [Symbol] +:bullet+, +:decimal+, +:lower_alpha+, +:upper_alpha+,
+  #     +:lower_roman+, or +:upper_roman+.
+  # @!attribute [r] start
+  #   @return [Integer] the ordinal the first item counts from.
+  # @!attribute [r] items
+  #   @return [Array<ListItem>]
+  class List < Data.define(:marker, :start, :items)
+    # @return [Boolean] whether the list is numbered.
+    def ordered? = marker != :bullet
+  end
+
+  # One item of a {List}.
+  #
+  # @!attribute [r] blocks
+  #   @return [Array<Block>]
+  # @!attribute [r] checked
+  #   @return [Boolean, nil] task-list state, when the item carries a
+  #     checkbox.
+  # @!attribute [r] marker_label
+  #   @return [String, nil] literal marker text that overrides the list marker
+  #     when the source number text cannot be reproduced from the marker and
+  #     position alone (composite number text such as +1-a)+).
+  class ListItem < Data.define(:blocks, :checked, :marker_label)
+  end
+
+  # A table as a canonical grid: every logical grid position appears exactly
+  # once. Content and spans live on the origin slot, and each position a span
+  # covers holds a +:covered+ slot pointing back at that origin.
+  #
+  # @!attribute [r] grid
+  #   @return [Array<Array<CellSlot>>] rows of slots. Rows may differ in
+  #     length when the source is ragged.
+  # @!attribute [r] header_rows
+  #   @return [Integer] number of leading rows that are header rows (0 = no
+  #     header).
+  # @!attribute [r] kind
+  #   @return [Symbol] +:data+ for a real data table, +:layout+ for layout
+  #     scaffolding (text boxes, positioning tables).
+  class Table < Data.define(:grid, :header_rows, :kind)
+  end
+
+  # One position in a {Table#grid}: either a cell or the shadow of one.
+  #
+  # @!attribute [r] kind
+  #   @return [Symbol] +:origin+ or +:covered+.
+  # @!attribute [r] cell
+  #   @return [Cell, nil] origin.
+  # @!attribute [r] origin_row
+  #   @return [Integer, nil] covered: row of the origin this position belongs
+  #     to.
+  # @!attribute [r] origin_col
+  #   @return [Integer, nil] covered: column of the origin this position
+  #     belongs to.
+  class CellSlot < Data.define(:kind, :cell, :origin_row, :origin_col)
+  end
+
+  # A table cell and the extent it spans.
+  #
+  # @!attribute [r] blocks
+  #   @return [Array<Block>]
+  # @!attribute [r] col_span
+  #   @return [Integer] columns covered, at least 1.
+  # @!attribute [r] row_span
+  #   @return [Integer] rows covered, at least 1.
+  class Cell < Data.define(:blocks, :col_span, :row_span)
+  end
+
+  # A footnote or endnote body, referenced from text by a +:note_ref+ inline.
+  #
+  # @!attribute [r] id
+  #   @return [String] the id the referencing inline carries.
+  # @!attribute [r] kind
+  #   @return [Symbol] +:footnote+ or +:endnote+, by where the source places
+  #     the note.
+  # @!attribute [r] blocks
+  #   @return [Array<Block>] the note's own content.
+  class Note < Data.define(:id, :kind, :blocks)
+  end
+
+  # An embedded binary asset (image, object payload). Bytes are always
+  # retained, so a document stays self-contained.
+  #
+  # @!attribute [r] id
+  #   @return [Integer] index into {Document#assets}, as referenced by an
+  #     image source.
+  # @!attribute [r] media_type
+  #   @return [String] MIME type, e.g. +image/png+.
+  # @!attribute [r] origin_part
+  #   @return [String] package part or stream the asset came from, for
+  #     provenance.
+  # @!attribute [r] data
+  #   @return [String] the payload, exactly as stored in the source, as a
+  #     binary (ASCII-8BIT) string.
+  class Asset < Data.define(:id, :media_type, :origin_part, :data)
+  end
+end

data/lib/anydoc/errors.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Anydoc
+  # Base class for everything this gem raises. Unreadable files raise the
+  # +Errno+ exception any other read of them would, and a format argument
+  # naming no supported format raises +ArgumentError+.
+  class Error < StandardError; end
+
+  # Meaningful conversion was impossible. Rescue this to handle every kind of
+  # failure at once, or one of its subclasses to single one out.
+  #
+  # Recoverable producer quirks never reach here: they are recovered or
+  # skipped while conversion continues.
+  class ConvertError < Error; end
+
+  # The format is unknown, or cannot be converted at all: a scanned or
+  # image-only PDF needs OCR, which anydoc does not do.
+  class UnsupportedError < ConvertError; end
+
+  # The document is structurally unusable: no meaningful content could be
+  # extracted.
+  class MalformedError < ConvertError
+    # @return [String, nil] the package part or stream at fault, or +nil+ when
+    #   no single part is.
+    attr_reader :part
+  end
+
+  # The document is encrypted or password-protected.
+  class EncryptedError < ConvertError; end
+
+  # A fixed safety limit was crossed: decompression, nesting depth, node
+  # count, repeat expansion, or retained asset bytes.
+  class ResourceLimitError < ConvertError
+    # @return [Symbol] the limit that was crossed, e.g. +:max_entry_bytes+.
+    attr_reader :limit
+  end
+
+  # A part required for any meaningful output is absent.
+  class MissingPartError < ConvertError
+    # @return [String] the part or stream that is missing.
+    attr_reader :part
+  end
+end

data/lib/anydoc/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Anydoc
+  # The gem version, which is the version of the anydoc crate it wraps.
+  VERSION = "0.1.7"
+end

data/lib/anydoc.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "anydoc/version"
+require_relative "anydoc/errors"
+require_relative "anydoc/document"
+
+# Precompiled gems carry one extension per Ruby ABI; a gem built from source
+# puts its single extension straight into lib/anydoc.
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "anydoc/#{Regexp.last_match(1)}/anydoc"
+rescue LoadError
+  require_relative "anydoc/anydoc"
+end
+
+# Convert documents (Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, CSV,
+# and PDF) to GitHub-Flavored Markdown.
+#
+#   Anydoc.to_markdown("report.docx")
+#
+# Every format parses into one shared document model and renders through a
+# single Markdown serializer, so headings, tables, lists, and footnotes come
+# out the same no matter which format goes in.
+#
+# @see FORMATS the formats that can be named explicitly.
+module Anydoc
+  # @!parse
+  #   # Every format anydoc reads, named after the extension that identifies
+  #   # it. Container variants that share a parser (+.docm+, +.xlsm+,
+  #   # +.ppsx+, ...) map onto these through {format_from_bytes} or
+  #   # {format_from_extension}.
+  #   #
+  #   # @return [Array<Symbol>]
+  #   FORMATS = %i[doc docx odt pdf ppt pptx rtf epub xlsx ods odp csv].freeze
+
+  class << self
+    # Convert a document file to Markdown. The format is detected from the
+    # file content; the extension is the fallback for signature-less formats
+    # (CSV) and unrecognizable containers.
+    #
+    # @param path [String, Pathname] the file to convert.
+    # @return [String] GitHub-Flavored Markdown.
+    # @raise [ConvertError] if no meaningful Markdown could come out of it.
+    # @raise [SystemCallError] if the file could not be read.
+    def to_markdown(path)
+      path = File.path(path)
+      data = File.binread(path)
+      format = format_from_bytes(data) || format_from_path(path)
+      unless format
+        raise UnsupportedError,
+              "unsupported input: unrecognized file content and extension: #{path}"
+      end
+
+      to_markdown_bytes(data, format: format)
+    end
+
+    # Convert an in-memory document to Markdown.
+    #
+    # @param data [String] the document's bytes.
+    # @param format [Symbol, String, nil] which format to parse it as. Left
+    #   out, the format is detected from the content, which signature-less
+    #   formats (CSV) have to name explicitly.
+    # @return [String] GitHub-Flavored Markdown.
+    # @raise [ConvertError] if no meaningful Markdown could come out of it.
+    # @raise [ArgumentError] if +format+ names no supported format.
+    def to_markdown_bytes(data, format: nil)
+      Native.to_markdown_bytes(data, format_symbol(format))
+    end
+
+    # Parse an in-memory document into the document model, which also carries
+    # the embedded assets.
+    #
+    # Unsupported for +:pdf+: PDF conversion produces Markdown directly and
+    # has no document-model form; use {to_markdown_bytes}.
+    #
+    # @param data [String] the document's bytes.
+    # @param format [Symbol, String, nil] which format to parse it as. Left
+    #   out, the format is detected from the content.
+    # @return [Document]
+    # @raise [ConvertError] if the document could not be parsed.
+    # @raise [ArgumentError] if +format+ names no supported format.
+    def to_document(data, format: nil)
+      Native.to_document(data, format_symbol(format))
+    end
+
+    # Detect the format from the content itself: the signature and identity
+    # each container specification designates (PDF header, RTF open group, OLE
+    # stream names, ZIP package mimetype/content types).
+    #
+    # @param data [String] the document's bytes.
+    # @return [Symbol, nil] +nil+ for plain-text formats, which carry no
+    #   signature, and for anything unrecognized.
+    def format_from_bytes(data)
+      Native.format_from_bytes(data)
+    end
+
+    # The format an extension names, with or without a leading dot, matched
+    # case-insensitively.
+    #
+    # @param extension [String, Symbol] e.g. +".pptm"+.
+    # @return [Symbol, nil] +nil+ for anything unrecognized.
+    def format_from_extension(extension)
+      Native.format_from_extension(extension.to_s.delete_prefix("."))
+    end
+
+    # The format a path's extension names.
+    #
+    # @param path [String, Pathname] the path to read the extension off.
+    # @return [Symbol, nil] +nil+ when the path has no extension or names
+    #   nothing recognized.
+    def format_from_path(path)
+      extension = File.extname(File.path(path))
+      extension.empty? ? nil : format_from_extension(extension)
+    end
+
+    private
+
+    # Format arguments are symbols; strings are accepted for convenience.
+    def format_symbol(format)
+      case format
+      when nil, Symbol then format
+      when String then format.to_sym
+      else
+        raise ArgumentError, "format must be a Symbol, a String, or nil, got #{format.class}"
+      end
+    end
+  end
+end

data/sig/anydoc.rbs

@@ -0,0 +1,163 @@
+# Type signatures for anydoc-ruby.
+
+module Anydoc
+  VERSION: String
+
+  # Every format anydoc reads, named after the extension that identifies it.
+  FORMATS: Array[Symbol]
+
+  type format = Symbol | String
+  type path = String | ::Pathname | _ToPath
+
+  def self.to_markdown: (path path) -> String
+  def self.to_markdown_bytes: (String data, ?format: format?) -> String
+  def self.to_document: (String data, ?format: format?) -> Document
+  def self.format_from_bytes: (String data) -> Symbol?
+  def self.format_from_extension: (String | Symbol extension) -> Symbol?
+  def self.format_from_path: (path path) -> Symbol?
+
+  # Argument coercion and file reading happen in Ruby; these are the raw
+  # entry points the extension defines.
+  #
+  # @api private
+  module Native
+    def self.to_markdown_bytes: (String data, Symbol? format) -> String
+    def self.to_document: (String data, Symbol? format) -> Document
+    def self.format_from_bytes: (String data) -> Symbol?
+    def self.format_from_extension: (String extension) -> Symbol?
+  end
+
+  class Error < StandardError
+  end
+
+  class ConvertError < Error
+  end
+
+  class UnsupportedError < ConvertError
+  end
+
+  class MalformedError < ConvertError
+    attr_reader part: String?
+  end
+
+  class EncryptedError < ConvertError
+  end
+
+  class ResourceLimitError < ConvertError
+    attr_reader limit: Symbol
+  end
+
+  class MissingPartError < ConvertError
+    attr_reader part: String
+  end
+
+  class Document < ::Data
+    attr_reader blocks: Array[Block]
+    attr_reader notes: Array[Note]
+    attr_reader assets: Array[Asset]
+
+    def self.new: (Array[Block] blocks, Array[Note] notes, Array[Asset] assets) -> Document
+                | (blocks: Array[Block], notes: Array[Note], assets: Array[Asset]) -> Document
+  end
+
+  class Block < ::Data
+    # :heading | :paragraph | :list | :table | :block_quote | :code_block | :rule
+    attr_reader kind: Symbol
+    attr_reader level: Integer?
+    attr_reader anchor: String?
+    attr_reader content: Array[Inline]?
+    attr_reader list: List?
+    attr_reader table: Table?
+    attr_reader blocks: Array[Block]?
+    attr_reader lang: String?
+    attr_reader text: String?
+  end
+
+  class Inline < ::Data
+    # :text | :link | :image | :anchor | :note_ref | :line_break
+    attr_reader kind: Symbol
+    attr_reader text: String?
+    attr_reader style: Style?
+    attr_reader content: Array[Inline]?
+    attr_reader target: LinkTarget?
+    attr_reader alt: String?
+    attr_reader source: ImageSource?
+    attr_reader anchor: String?
+    attr_reader note_id: String?
+  end
+
+  class Style < ::Data
+    attr_reader bold: bool
+    attr_reader italic: bool
+    attr_reader strike: bool
+    attr_reader code: bool
+
+    def self.new: (bool bold, bool italic, bool strike, bool code) -> Style
+                | (bold: bool, italic: bool, strike: bool, code: bool) -> Style
+
+    def plain?: () -> bool
+  end
+
+  class LinkTarget < ::Data
+    # :external | :relative | :anchor
+    attr_reader kind: Symbol
+    attr_reader value: String
+  end
+
+  class ImageSource < ::Data
+    # :external | :asset | :unavailable
+    attr_reader kind: Symbol
+    attr_reader url: String?
+    attr_reader asset_id: Integer?
+  end
+
+  class List < ::Data
+    # :bullet | :decimal | :lower_alpha | :upper_alpha | :lower_roman | :upper_roman
+    attr_reader marker: Symbol
+    attr_reader start: Integer
+    attr_reader items: Array[ListItem]
+
+    def ordered?: () -> bool
+  end
+
+  class ListItem < ::Data
+    attr_reader blocks: Array[Block]
+    attr_reader checked: bool?
+    attr_reader marker_label: String?
+  end
+
+  class Table < ::Data
+    attr_reader grid: Array[Array[CellSlot]]
+    attr_reader header_rows: Integer
+    # :data | :layout
+    attr_reader kind: Symbol
+  end
+
+  class CellSlot < ::Data
+    # :origin | :covered
+    attr_reader kind: Symbol
+    attr_reader cell: Cell?
+    attr_reader origin_row: Integer?
+    attr_reader origin_col: Integer?
+  end
+
+  class Cell < ::Data
+    attr_reader blocks: Array[Block]
+    attr_reader col_span: Integer
+    attr_reader row_span: Integer
+  end
+
+  class Note < ::Data
+    attr_reader id: String
+    # :footnote | :endnote
+    attr_reader kind: Symbol
+    attr_reader blocks: Array[Block]
+  end
+
+  class Asset < ::Data
+    attr_reader id: Integer
+    attr_reader media_type: String
+    attr_reader origin_part: String
+    attr_reader data: String
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: anydoc-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.7
+platform: aarch64-linux
+authors:
+- Jan Sterba
+- Firecrawl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-08-06 00:00:00.000000000 Z
+dependencies: []
+description: Ruby bindings for the anydoc Rust crate. Converts Word, PowerPoint, Excel,
+  OpenDocument, RTF, EPUB, CSV, and PDF documents into clean GitHub-Flavored Markdown,
+  with one consistent output no matter which format goes in.
+email:
+- info@jansterba.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/anydoc.rb
+- lib/anydoc/3.2/anydoc.so
+- lib/anydoc/3.3/anydoc.so
+- lib/anydoc/3.4/anydoc.so
+- lib/anydoc/4.0/anydoc.so
+- lib/anydoc/document.rb
+- lib/anydoc/errors.rb
+- lib/anydoc/version.rb
+- sig/anydoc.rbs
+homepage: https://github.com/honzasterba/anydoc#readme
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/honzasterba/anydoc#readme
+  source_code_uri: https://github.com/honzasterba/anydoc/tree/main/ruby
+  bug_tracker_uri: https://github.com/honzasterba/anydoc/issues
+  changelog_uri: https://github.com/honzasterba/anydoc/releases
+  documentation_uri: https://github.com/honzasterba/anydoc/blob/main/ruby/README.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Convert documents (doc, docx, odt, rtf, epub, pdf, presentations, spreadsheets,
+  csv) to GitHub-Flavored Markdown
+test_files: []