html-to-markdown 3.1.0 → 3.2.1

data/ext/html-to-markdown-rb/native/Cargo.toml

@@ -1,48 +0,0 @@
-[package]
-name = "html-to-markdown-rb"
-version = "3.1.0"
-edition = "2024"
-authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
-license = "MIT"
-repository = "https://github.com/kreuzberg-dev/html-to-markdown"
-homepage = "https://github.com/kreuzberg-dev/html-to-markdown"
-documentation = "https://docs.rs/html-to-markdown-rs"
-readme = "README.md"
-rust-version = "1.85"
-description = "Ruby bindings (Magnus) for html-to-markdown - high-performance HTML to Markdown converter"
-keywords = ["html", "markdown", "ruby", "magnus", "bindings"]
-categories = ["api-bindings"]
-
-[lib]
-name = "html_to_markdown_rb"
-crate-type = ["cdylib", "rlib"]
-
-[dependencies]
-html-to-markdown-rs = { path = "../../../vendor/html-to-markdown-rs", features = [
-  "inline-images",
-  "visitor",
-  "metadata",
-] }
-magnus = { git = "https://github.com/matsadler/magnus", rev = "f6db11769efb517427bf7f121f9c32e18b059b38", features = [
-  "rb-sys",
-] }
-[dev-dependencies]
-pretty_assertions = "1.4"
-
-[features]
-default = ["inline-images", "metadata", "visitor"]
-inline-images = ["html-to-markdown-rs/inline-images"]
-metadata = ["html-to-markdown-rs/metadata"]
-visitor = ["html-to-markdown-rs/visitor"]
-
-[lints.rust]
-unsafe_code = "forbid"
-missing_docs = "warn"
-unused_must_use = "deny"
-
-[lints.clippy]
-all = { level = "deny", priority = -1 }
-cargo = { level = "deny", priority = -1 }
-pedantic = { level = "warn", priority = -1 }
-nursery = { level = "warn", priority = -1 }
-multiple_crate_versions = "allow"

data/ext/html-to-markdown-rb/native/README.md

@@ -1,215 +0,0 @@
-# html-to-markdown-rb
-
-Blazing-fast HTML → Markdown conversion for Ruby, powered by the same Rust engine used by our Python, Node.js, WebAssembly, and PHP packages. Ship identical Markdown across every runtime while enjoying native extension performance.
-
-[![Crates.io](https://img.shields.io/crates/v/html-to-markdown-rs.svg)](https://crates.io/crates/html-to-markdown-rs)
-[![npm (node)](https://img.shields.io/npm/v/html-to-markdown-node.svg?logo=npm)](https://www.npmjs.com/package/html-to-markdown-node)
-[![npm (wasm)](https://img.shields.io/npm/v/html-to-markdown-wasm.svg?logo=npm)](https://www.npmjs.com/package/html-to-markdown-wasm)
-[![PyPI](https://img.shields.io/pypi/v/html-to-markdown.svg?logo=pypi)](https://pypi.org/project/html-to-markdown/)
-[![Packagist](https://img.shields.io/packagist/v/goldziher/html-to-markdown.svg)](https://packagist.org/packages/goldziher/html-to-markdown)
-[![RubyGems](https://badge.fury.io/rb/html-to-markdown.svg)](https://rubygems.org/gems/html-to-markdown)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/kreuzberg-dev/html-to-markdown/blob/main/LICENSE)
-
-## Features
-
-- ⚡ **Rust-fast**: Ruby bindings around a highly optimised Rust core (60‑80× faster than BeautifulSoup-based converters).
-- 🔁 **Identical output**: Shares logic with the Python wheels, npm bindings, PHP extension, WASM package, and CLI — consistent Markdown everywhere.
-- ⚙️ **Rich configuration**: Control heading styles, list indentation, whitespace handling, HTML preprocessing, and more.
-- 🖼️ **Inline image extraction**: Pull out embedded images (PNG/JPEG/SVG/data URIs) alongside Markdown.
-- 🧰 **Bundled CLI proxy**: Call the Rust CLI straight from Ruby or shell scripts.
-- 🛠️ **First-class Rails support**: Works with `Gem.win_platform?` builds, supports Trusted Publishing, and compiles on install if no native gem matches.
-
-## Documentation & Support
-
-- [GitHub repository](https://github.com/kreuzberg-dev/html-to-markdown)
-- [Issue tracker](https://github.com/kreuzberg-dev/html-to-markdown/issues)
-- [Changelog](https://github.com/kreuzberg-dev/html-to-markdown/blob/main/CHANGELOG.md)
-- [Live demo (WASM)](https://kreuzberg-dev.github.io/html-to-markdown/)
-
-## Installation
-
-```bash
-bundle add html-to-markdown
-# or
-gem install html-to-markdown
-```
-
-Add the gem to your project and Bundler will compile the native Rust extension on first install.
-
-### Requirements
-
-- Ruby **3.2+** (Magnus relies on the fiber scheduler APIs added in 3.2)
-- Rust toolchain **1.85+** with Cargo available on your `$PATH`
-- Ruby development headers (`ruby-dev`, `ruby-devel`, or the platform equivalent)
-
-**Windows**: install [RubyInstaller with MSYS2](https://rubyinstaller.org/) (UCRT64). Run once:
-
-```powershell
-ridk exec pacman -S --needed --noconfirm base-devel mingw-w64-ucrt-x86_64-toolchain
-```
-
-This provides the standard headers (including `strings.h`) required for the bindgen step.
-
-## Performance Snapshot
-
-Apple M4 • Real Wikipedia documents • `HtmlToMarkdown.convert` (Ruby)
-
-| Document            | Size  | Latency | Throughput | Docs/sec |
-| ------------------- | ----- | ------- | ---------- | -------- |
-| Lists (Timeline)    | 129KB | 0.69ms  | 187 MB/s   | 1,450    |
-| Tables (Countries)  | 360KB | 2.19ms  | 164 MB/s   | 456      |
-| Mixed (Python wiki) | 656KB | 4.88ms  | 134 MB/s   | 205      |
-
-> Same core, same benchmarks: the Ruby extension stays within single-digit % of the Rust CLI and mirrors the Python/Node numbers.
-
-### Benchmark Fixtures (Apple M4)
-
-Measured via `task bench:harness` with the shared Wikipedia + hOCR suite:
-
-| Document               | Size   | ops/sec (Ruby) |
-| ---------------------- | ------ | -------------- |
-| Lists (Timeline)       | 129 KB | 3,156          |
-| Tables (Countries)     | 360 KB | 921            |
-| Medium (Python)        | 657 KB | 469            |
-| Large (Rust)           | 567 KB | 534            |
-| Small (Intro)          | 463 KB | 629            |
-| hOCR German PDF        | 44 KB  | 7,250          |
-| hOCR Invoice           | 4 KB   | 83,883         |
-| hOCR Embedded Tables   | 37 KB  | 7,890          |
-
-## Quick Start
-
-```ruby
-require 'html_to_markdown'
-
-html = <<~HTML
-  <h1>Welcome</h1>
-  <p>This is <strong>Rust-fast</strong> conversion!</p>
-  <ul>
-    <li>Native extension</li>
-    <li>Identical output across languages</li>
-  </ul>
-HTML
-
-markdown = HtmlToMarkdown.convert(html)
-puts markdown
-# # Welcome
-#
-# This is **Rust-fast** conversion!
-#
-# - Native extension
-# - Identical output across languages
-```
-
-## API
-
-### Conversion Options
-
-Pass a Ruby hash (string or symbol keys) to tweak rendering. Every option maps one-for-one with the Rust/Python/Node APIs.
-
-```ruby
-require 'html_to_markdown'
-
-markdown = HtmlToMarkdown.convert(
-  '<pre><code class="language-ruby">puts "hi"</code></pre>',
-  heading_style: :atx,
-  code_block_style: :fenced,
-  bullets: '*+-',
-  list_indent_type: :spaces,
-  list_indent_width: 2,
-  whitespace_mode: :normalized,
-  highlight_style: :double_equal
-)
-
-puts markdown
-```
-
-### HTML Preprocessing
-
-Clean up scraped HTML (navigation, forms, malformed markup) before conversion:
-
-```ruby
-require 'html_to_markdown'
-
-markdown = HtmlToMarkdown.convert(
-  html,
-  preprocessing: {
-    enabled: true,
-    preset: :aggressive, # :minimal, :standard, :aggressive
-    remove_navigation: true,
-    remove_forms: true
-  }
-)
-```
-
-### Inline Images
-
-Convert HTML with inline images (data URIs, SVG) to Markdown.
-
-```ruby
-require 'html_to_markdown'
-
-markdown = HtmlToMarkdown.convert(
-  '<img src="data:image/png;base64,iVBORw0..." alt="Pixel">'
-)
-
-puts markdown
-```
-
-## CLI
-
-The gem bundles a small proxy for the Rust CLI binary. Use it when you need parity with the standalone `html-to-markdown` executable.
-
-```ruby
-require 'html_to_markdown/cli'
-
-HtmlToMarkdown::CLI.run(%w[--heading-style atx input.html], stdout: $stdout)
-# => writes converted Markdown to STDOUT
-```
-
-You can also call the CLI binary directly for scripting:
-
-```ruby
-HtmlToMarkdown::CLIProxy.call(['--version'])
-# => "html-to-markdown 2.5.7"
-```
-
-Rebuild the CLI locally if you see `CLI binary not built` during tests:
-
-```bash
-bundle exec rake compile          # builds the extension
-bundle exec ruby scripts/prepare_ruby_gem.rb  # copies the CLI into lib/bin/
-```
-
-## Error Handling
-
-Conversion errors raise `HtmlToMarkdown::Error` (wrapping the Rust error context). CLI invocations use specialised subclasses:
-
-- `HtmlToMarkdown::CLIProxy::MissingBinaryError`
-- `HtmlToMarkdown::CLIProxy::CLIExecutionError`
-
-Rescue them to provide clearer feedback in your application.
-
-## Consistent Across Languages
-
-The Ruby gem shares the exact Rust core with:
-
-- [Python wheels](https://pypi.org/project/html-to-markdown/)
-- [Node.js / Bun bindings](https://www.npmjs.com/package/html-to-markdown-node)
-- [WebAssembly package](https://www.npmjs.com/package/html-to-markdown-wasm)
-- The Rust crate and CLI
-
-Use whichever runtime fits your stack while keeping formatting behaviour identical.
-
-## Development
-
-```bash
-bundle exec rake compile   # build the native extension
-bundle exec rspec          # run test suite
-```
-
-The extension uses [Magnus](https://github.com/matsadler/magnus) plus `rb-sys` for bindgen. When editing the Rust code under `src/`, rerun `rake compile`.
-
-## License
-
-MIT © Na'aman Hirschfeld

data/ext/html-to-markdown-rb/native/src/conversion/inline_images.rs

@@ -1,54 +0,0 @@
-//! Inline image configuration and conversion functions.
-
-use html_to_markdown_rs::InlineImage;
-use magnus::prelude::*;
-use magnus::{Error, Ruby, Value};
-
-pub fn inline_image_to_value(ruby: &Ruby, image: InlineImage) -> Result<Value, Error> {
-    let InlineImage {
-        data,
-        format,
-        filename,
-        description,
-        dimensions,
-        source,
-        attributes,
-    } = image;
-
-    let hash = ruby.hash_new();
-    let data_value = ruby.str_from_slice(&data);
-    hash.aset(ruby.intern("data"), data_value)?;
-
-    let format_value = format.to_string();
-    hash.aset(ruby.intern("format"), format_value)?;
-
-    match filename {
-        Some(name) => hash.aset(ruby.intern("filename"), name)?,
-        None => hash.aset(ruby.intern("filename"), ruby.qnil())?,
-    }
-
-    match description {
-        Some(desc) => hash.aset(ruby.intern("description"), desc)?,
-        None => hash.aset(ruby.intern("description"), ruby.qnil())?,
-    }
-
-    if let Some((width, height)) = dimensions {
-        let dims = ruby.ary_new();
-        dims.push(i64::from(width))?;
-        dims.push(i64::from(height))?;
-        hash.aset(ruby.intern("dimensions"), dims)?;
-    } else {
-        hash.aset(ruby.intern("dimensions"), ruby.qnil())?;
-    }
-
-    let source_value = source.to_string();
-    hash.aset(ruby.intern("source"), source_value)?;
-
-    let attrs = ruby.hash_new();
-    for (key, value) in attributes {
-        attrs.aset(key, value)?;
-    }
-    hash.aset(ruby.intern("attributes"), attrs)?;
-
-    Ok(hash.as_value())
-}

data/ext/html-to-markdown-rb/native/src/conversion/metadata.rs

@@ -1,158 +0,0 @@
-//! Metadata configuration and conversion functions.
-
-use html_to_markdown_rs::metadata::{
-    DocumentMetadata as RustDocumentMetadata, HeaderMetadata as RustHeaderMetadata,
-    HtmlMetadata as RustHtmlMetadata, ImageMetadata as RustImageMetadata, LinkMetadata as RustLinkMetadata,
-    StructuredData as RustStructuredData, TextDirection as RustTextDirection,
-};
-use magnus::prelude::*;
-use magnus::{Error, Ruby, Value};
-
-fn opt_string_to_ruby(ruby: &Ruby, opt: Option<String>) -> Result<Value, Error> {
-    match opt {
-        Some(val) => Ok(ruby.str_from_slice(val.as_bytes()).as_value()),
-        None => Ok(ruby.qnil().as_value()),
-    }
-}
-
-fn btreemap_to_ruby_hash(ruby: &Ruby, map: std::collections::BTreeMap<String, String>) -> Result<Value, Error> {
-    let hash = ruby.hash_new();
-    for (k, v) in map {
-        hash.aset(k, v)?;
-    }
-    Ok(hash.as_value())
-}
-
-fn text_direction_to_string(text_direction: Option<RustTextDirection>) -> Option<String> {
-    text_direction.map(|direction| direction.to_string())
-}
-
-fn document_metadata_to_ruby(ruby: &Ruby, doc: RustDocumentMetadata) -> Result<Value, Error> {
-    let hash = ruby.hash_new();
-
-    hash.aset(ruby.intern("title"), opt_string_to_ruby(ruby, doc.title)?)?;
-    hash.aset(ruby.intern("description"), opt_string_to_ruby(ruby, doc.description)?)?;
-
-    let keywords = ruby.ary_new();
-    for keyword in doc.keywords {
-        keywords.push(keyword)?;
-    }
-    hash.aset(ruby.intern("keywords"), keywords)?;
-
-    hash.aset(ruby.intern("author"), opt_string_to_ruby(ruby, doc.author)?)?;
-    hash.aset(
-        ruby.intern("canonical_url"),
-        opt_string_to_ruby(ruby, doc.canonical_url)?,
-    )?;
-    hash.aset(ruby.intern("base_href"), opt_string_to_ruby(ruby, doc.base_href)?)?;
-    hash.aset(ruby.intern("language"), opt_string_to_ruby(ruby, doc.language)?)?;
-
-    match text_direction_to_string(doc.text_direction) {
-        Some(dir) => hash.aset(ruby.intern("text_direction"), dir)?,
-        None => hash.aset(ruby.intern("text_direction"), ruby.qnil())?,
-    }
-
-    hash.aset(ruby.intern("open_graph"), btreemap_to_ruby_hash(ruby, doc.open_graph)?)?;
-    hash.aset(
-        ruby.intern("twitter_card"),
-        btreemap_to_ruby_hash(ruby, doc.twitter_card)?,
-    )?;
-    hash.aset(ruby.intern("meta_tags"), btreemap_to_ruby_hash(ruby, doc.meta_tags)?)?;
-
-    Ok(hash.as_value())
-}
-
-fn headers_to_ruby(ruby: &Ruby, headers: Vec<RustHeaderMetadata>) -> Result<Value, Error> {
-    let array = ruby.ary_new();
-    for header in headers {
-        let hash = ruby.hash_new();
-        hash.aset(ruby.intern("level"), header.level)?;
-        hash.aset(ruby.intern("text"), header.text)?;
-        hash.aset(ruby.intern("id"), opt_string_to_ruby(ruby, header.id)?)?;
-        hash.aset(ruby.intern("depth"), header.depth as i64)?;
-        hash.aset(ruby.intern("html_offset"), header.html_offset as i64)?;
-        array.push(hash)?;
-    }
-    Ok(array.as_value())
-}
-
-fn links_to_ruby(ruby: &Ruby, links: Vec<RustLinkMetadata>) -> Result<Value, Error> {
-    let array = ruby.ary_new();
-    for link in links {
-        let hash = ruby.hash_new();
-        hash.aset(ruby.intern("href"), link.href)?;
-        hash.aset(ruby.intern("text"), link.text)?;
-        hash.aset(ruby.intern("title"), opt_string_to_ruby(ruby, link.title)?)?;
-        hash.aset(ruby.intern("link_type"), link.link_type.to_string())?;
-
-        let rel_array = ruby.ary_new();
-        for r in link.rel {
-            rel_array.push(r)?;
-        }
-        hash.aset(ruby.intern("rel"), rel_array)?;
-
-        hash.aset(ruby.intern("attributes"), btreemap_to_ruby_hash(ruby, link.attributes)?)?;
-        array.push(hash)?;
-    }
-    Ok(array.as_value())
-}
-
-fn images_to_ruby(ruby: &Ruby, images: Vec<RustImageMetadata>) -> Result<Value, Error> {
-    let array = ruby.ary_new();
-    for image in images {
-        let hash = ruby.hash_new();
-        hash.aset(ruby.intern("src"), image.src)?;
-        hash.aset(ruby.intern("alt"), opt_string_to_ruby(ruby, image.alt)?)?;
-        hash.aset(ruby.intern("title"), opt_string_to_ruby(ruby, image.title)?)?;
-
-        match image.dimensions {
-            Some((width, height)) => {
-                let dims = ruby.ary_new();
-                dims.push(i64::from(width))?;
-                dims.push(i64::from(height))?;
-                hash.aset(ruby.intern("dimensions"), dims)?;
-            }
-            None => {
-                hash.aset(ruby.intern("dimensions"), ruby.qnil())?;
-            }
-        }
-
-        hash.aset(ruby.intern("image_type"), image.image_type.to_string())?;
-        hash.aset(
-            ruby.intern("attributes"),
-            btreemap_to_ruby_hash(ruby, image.attributes)?,
-        )?;
-        array.push(hash)?;
-    }
-    Ok(array.as_value())
-}
-
-fn structured_data_to_ruby(ruby: &Ruby, data: Vec<RustStructuredData>) -> Result<Value, Error> {
-    let array = ruby.ary_new();
-    for item in data {
-        let hash = ruby.hash_new();
-        hash.aset(ruby.intern("data_type"), item.data_type.to_string())?;
-        hash.aset(ruby.intern("raw_json"), item.raw_json)?;
-        hash.aset(ruby.intern("schema_type"), opt_string_to_ruby(ruby, item.schema_type)?)?;
-        array.push(hash)?;
-    }
-    Ok(array.as_value())
-}
-
-pub fn extended_metadata_to_ruby(ruby: &Ruby, metadata: RustHtmlMetadata) -> Result<Value, Error> {
-    let hash = ruby.hash_new();
-
-    hash.aset(
-        ruby.intern("document"),
-        document_metadata_to_ruby(ruby, metadata.document)?,
-    )?;
-    hash.aset(ruby.intern("headers"), headers_to_ruby(ruby, metadata.headers)?)?;
-    hash.aset(ruby.intern("links"), links_to_ruby(ruby, metadata.links)?)?;
-    hash.aset(ruby.intern("images"), images_to_ruby(ruby, metadata.images)?)?;
-    hash.aset(
-        ruby.intern("structured_data"),
-        structured_data_to_ruby(ruby, metadata.structured_data)?,
-    )?;
-
-    Ok(hash.as_value())
-}

data/ext/html-to-markdown-rb/native/src/conversion/mod.rs

@@ -1,11 +0,0 @@
-//! Conversion functions for Ruby bindings.
-
-pub mod inline_images;
-
-#[cfg(feature = "metadata")]
-pub mod metadata;
-
-pub use inline_images::*;
-
-#[cfg(feature = "metadata")]
-pub use metadata::*;

data/ext/html-to-markdown-rb/native/src/lib.rs

@@ -1,128 +0,0 @@
-#![allow(clippy::all, clippy::pedantic, clippy::nursery, missing_docs)]
-
-use html_to_markdown_rs::{error::ConversionError, safety::guard_panic};
-
-mod conversion;
-mod options;
-mod types;
-
-use options::build_conversion_options;
-use types::{arg_error, runtime_error};
-
-#[cfg(feature = "metadata")]
-use conversion::extended_metadata_to_ruby;
-
-use magnus::prelude::*;
-use magnus::{Error, Ruby, Value, function, scan_args::scan_args};
-
-fn conversion_error(err: ConversionError) -> Error {
-    match err {
-        ConversionError::ConfigError(msg) => arg_error(msg),
-        ConversionError::Panic(message) => {
-            runtime_error(format!("html-to-markdown panic during conversion: {message}"))
-        }
-        other => runtime_error(other.to_string()),
-    }
-}
-
-fn convert_full_fn(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
-    let parsed = scan_args::<(String,), (Option<Value>,), (), (), (), ()>(args)?;
-    let html = parsed.required.0;
-    let options = build_conversion_options(ruby, parsed.optional.0)?;
-
-    let result = guard_panic(|| html_to_markdown_rs::convert(&html, Some(options.clone())))
-        .map_err(conversion_error)?;
-
-    let hash = ruby.hash_new();
-
-    // content: Option<String>
-    match result.content {
-        Some(ref s) => hash.aset(ruby.intern("content"), s.as_str())?,
-        None => hash.aset(ruby.intern("content"), ruby.qnil())?,
-    }
-
-    // document: not yet exposed
-    hash.aset(ruby.intern("document"), ruby.qnil())?;
-
-    // metadata
-    #[cfg(feature = "metadata")]
-    {
-        let metadata_value = extended_metadata_to_ruby(ruby, result.metadata)?;
-        hash.aset(ruby.intern("metadata"), metadata_value)?;
-    }
-    #[cfg(not(feature = "metadata"))]
-    hash.aset(ruby.intern("metadata"), ruby.qnil())?;
-
-    // tables: Vec<TableData> with grid and markdown
-    {
-        let tables_array = ruby.ary_new();
-        for table in &result.tables {
-            let table_hash = ruby.hash_new();
-            let grid_hash = ruby.hash_new();
-            grid_hash.aset(ruby.intern("rows"), table.grid.rows as i64)?;
-            grid_hash.aset(ruby.intern("cols"), table.grid.cols as i64)?;
-            let cells_array = ruby.ary_new();
-            for cell in &table.grid.cells {
-                let cell_hash = ruby.hash_new();
-                cell_hash.aset(ruby.intern("content"), cell.content.as_str())?;
-                cell_hash.aset(ruby.intern("row"), cell.row as i64)?;
-                cell_hash.aset(ruby.intern("col"), cell.col as i64)?;
-                cell_hash.aset(ruby.intern("row_span"), cell.row_span as i64)?;
-                cell_hash.aset(ruby.intern("col_span"), cell.col_span as i64)?;
-                cell_hash.aset(ruby.intern("is_header"), cell.is_header)?;
-                cells_array.push(cell_hash)?;
-            }
-            grid_hash.aset(ruby.intern("cells"), cells_array)?;
-            table_hash.aset(ruby.intern("grid"), grid_hash)?;
-            table_hash.aset(ruby.intern("markdown"), table.markdown.as_str())?;
-            tables_array.push(table_hash)?;
-        }
-        hash.aset(ruby.intern("tables"), tables_array)?;
-    }
-
-    // images
-    #[cfg(feature = "inline-images")]
-    {
-        use conversion::inline_image_to_value;
-        let images_array = ruby.ary_new();
-        for image in result.images {
-            let image_value = inline_image_to_value(ruby, image)?;
-            images_array.push(image_value)?;
-        }
-        hash.aset(ruby.intern("images"), images_array)?;
-    }
-    #[cfg(not(feature = "inline-images"))]
-    {
-        let empty = ruby.ary_new();
-        hash.aset(ruby.intern("images"), empty)?;
-    }
-
-    // warnings
-    {
-        let warnings_array = ruby.ary_new();
-        for warning in &result.warnings {
-            let w_hash = ruby.hash_new();
-            w_hash.aset(ruby.intern("message"), warning.message.as_str())?;
-            let kind_str = match warning.kind {
-                html_to_markdown_rs::WarningKind::ImageExtractionFailed => "image_extraction_failed",
-                html_to_markdown_rs::WarningKind::EncodingFallback => "encoding_fallback",
-                html_to_markdown_rs::WarningKind::TruncatedInput => "truncated_input",
-                html_to_markdown_rs::WarningKind::MalformedHtml => "malformed_html",
-                html_to_markdown_rs::WarningKind::SanitizationApplied => "sanitization_applied",
-            };
-            w_hash.aset(ruby.intern("kind"), kind_str)?;
-            warnings_array.push(w_hash)?;
-        }
-        hash.aset(ruby.intern("warnings"), warnings_array)?;
-    }
-
-    Ok(hash.as_value())
-}
-
-#[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
-    let module = ruby.define_module("HtmlToMarkdown")?;
-    module.define_singleton_method("convert", function!(convert_full_fn, -1))?;
-
-    Ok(())
-}