html-to-markdown 2.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e0e6194a6f1f081dd93f13abb5e299118f8e92bb5a7f706d6dc3359439dd5ae
+  data.tar.gz: 7146575639b67ad477a74640d5cd8d19219bb58a60c0d1311595fd46ee9be2ad
+SHA512:
+  metadata.gz: 0d55454f4a640146ddbe4ed0173f140901a9bfc6c1333827a51c5f404aed8b38d7c90bd6910e15aef0dd2da25f91fbfe6c08b1b5e914e6fc2d466caca148d1f2
+  data.tar.gz: 88fbedd30ddacdbac50be232944ff331edf344129d91c9d0799d999443833f0726a963881e6e608892923a115d7e3b01cf041443f46363059ab2e68a9e6cde2f

data/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "html-to-markdown-rb"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+readme = "README.md"
+rust-version.workspace = true
+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"]
+
+[features]
+default = []
+
+[dependencies]
+html-to-markdown-rs = { workspace = true, features = ["inline-images"] }
+magnus = { git = "https://github.com/matsadler/magnus", rev = "f6db11769efb517427bf7f121f9c32e18b059b38", features = ["rb-sys"] }
+
+[dev-dependencies]
+pretty_assertions = "1.4"

data/README.md

@@ -0,0 +1,146 @@
+# html-to-markdown-rb
+
+Ruby bindings for the `html-to-markdown` Rust engine – the same core that powers the Python wheels, Node.js NAPI bindings, WebAssembly package, and CLI. The gem exposes fast HTML → Markdown conversion with identical rendering behaviour across every supported language.
+
+[![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/Goldziher/html-to-markdown/blob/main/LICENSE)
+
+## 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.
+
+## 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
+```
+
+### Conversion with Options
+
+All configuration mirrors the Rust API. Options accept symbols or strings and match the same defaults as the other bindings.
+
+```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: ['*', '-', '+'],
+  wrap: true,
+  wrap_width: 80,
+  preserve_tags: %w[table figure]
+)
+```
+
+### Inline Images
+
+Extract inline binary data (data URIs, SVG) together with the converted Markdown.
+
+```ruby
+require 'html_to_markdown'
+
+result = HtmlToMarkdown.convert_with_inline_images(
+  '<img src="data:image/png;base64,iVBORw0..." alt="Pixel">',
+  image_config: {
+    max_decoded_size_bytes: 1 * 1024 * 1024,
+    infer_dimensions: true,
+    filename_prefix: 'img_',
+    capture_svg: true
+  }
+)
+
+puts result.markdown
+result.inline_images.each do |img|
+  puts "#{img.filename} -> #{img.format} (#{img.data.bytesize} bytes)"
+end
+```
+
+### CLI Proxy
+
+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.1"
+```
+
+### 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/exe/html-to-markdown

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'html_to_markdown/cli'
+
+exit HtmlToMarkdown::CLI.run(ARGV)

data/extconf.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+require 'rbconfig'
+
+if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+  devkit = ENV['RI_DEVKIT']
+  prefix = ENV['MSYSTEM_PREFIX'] || '/ucrt64'
+
+  if devkit
+    sysroot = "#{devkit}#{prefix}".tr('\\\\', '/')
+    extra_args = [
+      '--target=x86_64-pc-windows-gnu',
+      "--sysroot=#{sysroot}"
+    ]
+
+    existing = ENV['BINDGEN_EXTRA_CLANG_ARGS'].to_s.split(/\s+/)
+    ENV['BINDGEN_EXTRA_CLANG_ARGS'] = (existing + extra_args).uniq.join(' ')
+  end
+end
+
+default_profile = ENV.fetch('CARGO_PROFILE', 'release')
+
+create_rust_makefile('html_to_markdown_rb') do |config|
+  config.profile = default_profile.to_sym
+end

data/lib/html_to_markdown/cli.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'html_to_markdown/cli_proxy'
+
+module HtmlToMarkdown
+  module CLI
+    module_function
+
+    def run(argv = ARGV, stdout: $stdout, stderr: $stderr)
+      output = CLIProxy.call(argv)
+      stdout.print(output)
+      0
+    rescue CLIProxy::CLIExecutionError => e
+      stderr.print(e.stderr)
+      e.status || 1
+    rescue CLIProxy::MissingBinaryError, CLIProxy::Error => e
+      stderr.puts(e.message)
+      1
+    end
+  end
+end

data/lib/html_to_markdown/cli_proxy.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'pathname'
+
+module HtmlToMarkdown
+  module CLIProxy
+    Error = Class.new(StandardError)
+    MissingBinaryError = Class.new(Error)
+
+    class CLIExecutionError < Error
+      attr_reader :stderr, :status
+
+      def initialize(message, stderr:, status:)
+        super(message)
+        @stderr = stderr
+        @status = status
+      end
+    end
+
+    module_function
+
+    def call(argv)
+      binary = find_cli_binary
+      args = Array(argv).map(&:to_s)
+      stdout, stderr, status = Open3.capture3(binary.to_s, *args)
+      return stdout if status.success?
+
+      raise CLIExecutionError.new(
+        "html-to-markdown CLI exited with status #{status.exitstatus}",
+        stderr: stderr,
+        status: status.exitstatus
+      )
+    end
+
+    def find_cli_binary
+      binary_name = Gem.win_platform? ? 'html-to-markdown.exe' : 'html-to-markdown'
+      found = search_paths(binary_name).find(&:file?)
+      return found if found
+
+      raise MissingBinaryError, missing_binary_message
+    end
+
+    def root_path
+      @root_path ||= Pathname(__dir__).join('../..').expand_path
+    end
+
+    def lib_path
+      @lib_path ||= Pathname(__dir__).join('..').expand_path
+    end
+
+    def search_paths(binary_name)
+      paths = [
+        root_path.join('target', 'release', binary_name),
+        lib_path.join('bin', binary_name),
+        lib_path.join(binary_name)
+      ]
+
+      workspace_root = root_path.parent&.parent
+      paths << workspace_root.join('target', 'release', binary_name) if workspace_root
+      paths
+    end
+
+    def missing_binary_message
+      <<~MSG.strip
+        html-to-markdown CLI binary not found. Build it with
+        `cargo build --release --package html-to-markdown-cli`.
+      MSG
+    end
+  end
+end

data/lib/html_to_markdown/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HtmlToMarkdown
+  VERSION = '2.5.1'
+end

data/lib/html_to_markdown.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'html_to_markdown/version'
+require 'html_to_markdown_rb'
+
+module HtmlToMarkdown
+  autoload :CLI, 'html_to_markdown/cli'
+  autoload :CLIProxy, 'html_to_markdown/cli_proxy'
+
+  class << self
+    alias native_convert convert
+    alias native_convert_with_inline_images convert_with_inline_images
+  end
+
+  module_function
+
+  def convert(html, options = nil)
+    native_convert(html.to_s, options)
+  end
+
+  def convert_with_inline_images(html, options = nil, image_config = nil)
+    native_convert_with_inline_images(html.to_s, options, image_config)
+  end
+end

data/spec/cli_proxy_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'html_to_markdown/cli_proxy'
+require 'html_to_markdown/cli'
+require 'stringio'
+
+RSpec.describe HtmlToMarkdown::CLIProxy do
+  describe '.call' do
+    it 'executes the CLI binary' do
+      begin
+        binary = described_class.find_cli_binary
+      rescue HtmlToMarkdown::CLIProxy::MissingBinaryError
+        skip 'CLI binary not built'
+      end
+
+      expect(binary).to be_file
+
+      output = described_class.call(['--version'])
+      expect(output).to include(HtmlToMarkdown::VERSION)
+    end
+  end
+
+  describe HtmlToMarkdown::CLI do
+    it 'writes CLI output to stdout' do
+      begin
+        HtmlToMarkdown::CLIProxy.find_cli_binary
+      rescue HtmlToMarkdown::CLIProxy::MissingBinaryError
+        skip 'CLI binary not built'
+      end
+
+      stdout = StringIO.new
+      stderr = StringIO.new
+
+      exit_code = described_class.run(['--version'], stdout: stdout, stderr: stderr)
+
+      expect(exit_code).to eq(0)
+      expect(stdout.string).to include(HtmlToMarkdown::VERSION)
+      expect(stderr.string).to be_empty
+    end
+  end
+end

data/spec/convert_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe HtmlToMarkdown do
+  describe '.convert' do
+    it 'converts simple headings' do
+      expect(described_class.convert('<h1>Hello</h1>')).to eq("# Hello\n")
+    end
+
+    it 'accepts options hash' do
+      result = described_class.convert(
+        '<h1>Hello</h1>',
+        heading_style: :atx_closed,
+        default_title: true
+      )
+      expect(result).to include('Hello')
+    end
+  end
+
+  describe '.convert_with_inline_images' do
+    it 'returns inline images metadata' do
+      html = '<p><img src="data:image/png;base64,ZmFrZQ==" alt="fake"></p>'
+      extraction = described_class.convert_with_inline_images(html)
+      expect(extraction).to include(:markdown, :inline_images, :warnings)
+      expect(extraction[:inline_images].first[:description]).to eq('fake')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'html_to_markdown'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/src/lib.rs

@@ -0,0 +1,432 @@
+use html_to_markdown_rs::{
+    convert as convert_inner, convert_with_inline_images as convert_with_inline_images_inner, error::ConversionError,
+    CodeBlockStyle, ConversionOptions, HeadingStyle, HighlightStyle, HtmlExtraction, InlineImage, InlineImageConfig,
+    InlineImageFormat, InlineImageSource, InlineImageWarning, ListIndentType, NewlineStyle, PreprocessingOptions,
+    PreprocessingPreset, WhitespaceMode,
+};
+use magnus::prelude::*;
+use magnus::{function, scan_args::scan_args, Error, RArray, RHash, Ruby, Symbol, TryConvert, Value};
+
+const DEFAULT_INLINE_IMAGE_LIMIT: u64 = 5 * 1024 * 1024;
+
+fn conversion_error(err: ConversionError) -> Error {
+    match err {
+        ConversionError::ConfigError(msg) => arg_error(msg),
+        other => runtime_error(other.to_string()),
+    }
+}
+
+fn arg_error(message: impl Into<String>) -> Error {
+    let ruby = Ruby::get().expect("Ruby not initialised");
+    Error::new(ruby.exception_arg_error(), message.into())
+}
+
+fn runtime_error(message: impl Into<String>) -> Error {
+    let ruby = Ruby::get().expect("Ruby not initialised");
+    Error::new(ruby.exception_runtime_error(), message.into())
+}
+
+fn symbol_to_string(value: Value) -> Result<String, Error> {
+    if let Some(symbol) = Symbol::from_value(value) {
+        Ok(symbol.name()?.to_string())
+    } else {
+        String::try_convert(value)
+    }
+}
+
+fn get_kw(ruby: &Ruby, hash: RHash, name: &str) -> Option<Value> {
+    let sym = ruby.intern(name);
+    hash.get(sym).or_else(|| hash.get(name))
+}
+
+fn parse_heading_style(value: Value) -> Result<HeadingStyle, Error> {
+    match symbol_to_string(value)?.as_str() {
+        "underlined" => Ok(HeadingStyle::Underlined),
+        "atx" => Ok(HeadingStyle::Atx),
+        "atx_closed" => Ok(HeadingStyle::AtxClosed),
+        other => Err(arg_error(format!("invalid heading_style: {other}"))),
+    }
+}
+
+fn parse_list_indent_type(value: Value) -> Result<ListIndentType, Error> {
+    match symbol_to_string(value)?.as_str() {
+        "spaces" => Ok(ListIndentType::Spaces),
+        "tabs" => Ok(ListIndentType::Tabs),
+        other => Err(arg_error(format!("invalid list_indent_type: {other}"))),
+    }
+}
+
+fn parse_highlight_style(value: Value) -> Result<HighlightStyle, Error> {
+    match symbol_to_string(value)?.as_str() {
+        "double_equal" => Ok(HighlightStyle::DoubleEqual),
+        "html" => Ok(HighlightStyle::Html),
+        "bold" => Ok(HighlightStyle::Bold),
+        "none" => Ok(HighlightStyle::None),
+        other => Err(arg_error(format!("invalid highlight_style: {other}"))),
+    }
+}
+
+fn parse_whitespace_mode(value: Value) -> Result<WhitespaceMode, Error> {
+    match symbol_to_string(value)?.as_str() {
+        "normalized" => Ok(WhitespaceMode::Normalized),
+        "strict" => Ok(WhitespaceMode::Strict),
+        other => Err(arg_error(format!("invalid whitespace_mode: {other}"))),
+    }
+}
+
+fn parse_newline_style(value: Value) -> Result<NewlineStyle, Error> {
+    match symbol_to_string(value)?.as_str() {
+        "spaces" => Ok(NewlineStyle::Spaces),
+        "backslash" => Ok(NewlineStyle::Backslash),
+        other => Err(arg_error(format!("invalid newline_style: {other}"))),
+    }
+}
+
+fn parse_code_block_style(value: Value) -> Result<CodeBlockStyle, Error> {
+    match symbol_to_string(value)?.as_str() {
+        "indented" => Ok(CodeBlockStyle::Indented),
+        "backticks" => Ok(CodeBlockStyle::Backticks),
+        "tildes" => Ok(CodeBlockStyle::Tildes),
+        other => Err(arg_error(format!("invalid code_block_style: {other}"))),
+    }
+}
+
+fn parse_preset(value: Value) -> Result<PreprocessingPreset, Error> {
+    match symbol_to_string(value)?.as_str() {
+        "minimal" => Ok(PreprocessingPreset::Minimal),
+        "standard" => Ok(PreprocessingPreset::Standard),
+        "aggressive" => Ok(PreprocessingPreset::Aggressive),
+        other => Err(arg_error(format!("invalid preprocessing preset: {other}"))),
+    }
+}
+
+fn parse_vec_of_strings(value: Value) -> Result<Vec<String>, Error> {
+    let array = RArray::from_value(value).ok_or_else(|| arg_error("expected an Array of strings"))?;
+
+    array.to_vec::<String>()
+}
+
+fn parse_preprocessing_options(ruby: &Ruby, value: Value) -> Result<PreprocessingOptions, Error> {
+    let hash = RHash::from_value(value).ok_or_else(|| arg_error("expected preprocessing to be a Hash"))?;
+
+    let mut opts = PreprocessingOptions::default();
+
+    if let Some(enabled) = get_kw(ruby, hash, "enabled") {
+        opts.enabled = bool::try_convert(enabled)?;
+    }
+
+    if let Some(preset) = get_kw(ruby, hash, "preset") {
+        opts.preset = parse_preset(preset)?;
+    }
+
+    if let Some(remove_navigation) = get_kw(ruby, hash, "remove_navigation") {
+        opts.remove_navigation = bool::try_convert(remove_navigation)?;
+    }
+
+    if let Some(remove_forms) = get_kw(ruby, hash, "remove_forms") {
+        opts.remove_forms = bool::try_convert(remove_forms)?;
+    }
+
+    Ok(opts)
+}
+
+fn build_conversion_options(ruby: &Ruby, options: Option<Value>) -> Result<ConversionOptions, Error> {
+    let mut opts = ConversionOptions::default();
+
+    let Some(options) = options else {
+        return Ok(opts);
+    };
+
+    if options.is_nil() {
+        return Ok(opts);
+    }
+
+    let hash = RHash::from_value(options).ok_or_else(|| arg_error("options must be provided as a Hash"))?;
+
+    if let Some(heading_style) = get_kw(ruby, hash, "heading_style") {
+        opts.heading_style = parse_heading_style(heading_style)?;
+    }
+
+    if let Some(list_indent_type) = get_kw(ruby, hash, "list_indent_type") {
+        opts.list_indent_type = parse_list_indent_type(list_indent_type)?;
+    }
+
+    if let Some(list_indent_width) = get_kw(ruby, hash, "list_indent_width") {
+        opts.list_indent_width = usize::try_convert(list_indent_width)?;
+    }
+
+    if let Some(bullets) = get_kw(ruby, hash, "bullets") {
+        opts.bullets = String::try_convert(bullets)?;
+    }
+
+    if let Some(strong_em_symbol) = get_kw(ruby, hash, "strong_em_symbol") {
+        let value = String::try_convert(strong_em_symbol)?;
+        let mut chars = value.chars();
+        let ch = chars
+            .next()
+            .ok_or_else(|| arg_error("strong_em_symbol must not be empty"))?;
+        if chars.next().is_some() {
+            return Err(arg_error("strong_em_symbol must be a single character"));
+        }
+        opts.strong_em_symbol = ch;
+    }
+
+    if let Some(escape_asterisks) = get_kw(ruby, hash, "escape_asterisks") {
+        opts.escape_asterisks = bool::try_convert(escape_asterisks)?;
+    }
+
+    if let Some(escape_underscores) = get_kw(ruby, hash, "escape_underscores") {
+        opts.escape_underscores = bool::try_convert(escape_underscores)?;
+    }
+
+    if let Some(escape_misc) = get_kw(ruby, hash, "escape_misc") {
+        opts.escape_misc = bool::try_convert(escape_misc)?;
+    }
+
+    if let Some(escape_ascii) = get_kw(ruby, hash, "escape_ascii") {
+        opts.escape_ascii = bool::try_convert(escape_ascii)?;
+    }
+
+    if let Some(code_language) = get_kw(ruby, hash, "code_language") {
+        opts.code_language = String::try_convert(code_language)?;
+    }
+
+    if let Some(autolinks) = get_kw(ruby, hash, "autolinks") {
+        opts.autolinks = bool::try_convert(autolinks)?;
+    }
+
+    if let Some(default_title) = get_kw(ruby, hash, "default_title") {
+        opts.default_title = bool::try_convert(default_title)?;
+    }
+
+    if let Some(br_in_tables) = get_kw(ruby, hash, "br_in_tables") {
+        opts.br_in_tables = bool::try_convert(br_in_tables)?;
+    }
+
+    if let Some(hocr_spatial_tables) = get_kw(ruby, hash, "hocr_spatial_tables") {
+        opts.hocr_spatial_tables = bool::try_convert(hocr_spatial_tables)?;
+    }
+
+    if let Some(highlight_style) = get_kw(ruby, hash, "highlight_style") {
+        opts.highlight_style = parse_highlight_style(highlight_style)?;
+    }
+
+    if let Some(extract_metadata) = get_kw(ruby, hash, "extract_metadata") {
+        opts.extract_metadata = bool::try_convert(extract_metadata)?;
+    }
+
+    if let Some(whitespace_mode) = get_kw(ruby, hash, "whitespace_mode") {
+        opts.whitespace_mode = parse_whitespace_mode(whitespace_mode)?;
+    }
+
+    if let Some(strip_newlines) = get_kw(ruby, hash, "strip_newlines") {
+        opts.strip_newlines = bool::try_convert(strip_newlines)?;
+    }
+
+    if let Some(wrap) = get_kw(ruby, hash, "wrap") {
+        opts.wrap = bool::try_convert(wrap)?;
+    }
+
+    if let Some(wrap_width) = get_kw(ruby, hash, "wrap_width") {
+        opts.wrap_width = usize::try_convert(wrap_width)?;
+    }
+
+    if let Some(convert_as_inline) = get_kw(ruby, hash, "convert_as_inline") {
+        opts.convert_as_inline = bool::try_convert(convert_as_inline)?;
+    }
+
+    if let Some(sub_symbol) = get_kw(ruby, hash, "sub_symbol") {
+        opts.sub_symbol = String::try_convert(sub_symbol)?;
+    }
+
+    if let Some(sup_symbol) = get_kw(ruby, hash, "sup_symbol") {
+        opts.sup_symbol = String::try_convert(sup_symbol)?;
+    }
+
+    if let Some(newline_style) = get_kw(ruby, hash, "newline_style") {
+        opts.newline_style = parse_newline_style(newline_style)?;
+    }
+
+    if let Some(code_block_style) = get_kw(ruby, hash, "code_block_style") {
+        opts.code_block_style = parse_code_block_style(code_block_style)?;
+    }
+
+    if let Some(keep_inline_images_in) = get_kw(ruby, hash, "keep_inline_images_in") {
+        opts.keep_inline_images_in = parse_vec_of_strings(keep_inline_images_in)?;
+    }
+
+    if let Some(preprocessing) = get_kw(ruby, hash, "preprocessing") {
+        opts.preprocessing = parse_preprocessing_options(ruby, preprocessing)?;
+    }
+
+    if let Some(encoding) = get_kw(ruby, hash, "encoding") {
+        opts.encoding = String::try_convert(encoding)?;
+    }
+
+    if let Some(debug) = get_kw(ruby, hash, "debug") {
+        opts.debug = bool::try_convert(debug)?;
+    }
+
+    if let Some(strip_tags) = get_kw(ruby, hash, "strip_tags") {
+        opts.strip_tags = parse_vec_of_strings(strip_tags)?;
+    }
+
+    if let Some(preserve_tags) = get_kw(ruby, hash, "preserve_tags") {
+        opts.preserve_tags = parse_vec_of_strings(preserve_tags)?;
+    }
+
+    Ok(opts)
+}
+
+fn build_inline_image_config(ruby: &Ruby, config: Option<Value>) -> Result<InlineImageConfig, Error> {
+    let mut cfg = InlineImageConfig::new(DEFAULT_INLINE_IMAGE_LIMIT);
+
+    let Some(config) = config else {
+        return Ok(cfg);
+    };
+
+    if config.is_nil() {
+        return Ok(cfg);
+    }
+
+    let hash = RHash::from_value(config).ok_or_else(|| arg_error("inline image config must be provided as a Hash"))?;
+
+    if let Some(limit) = get_kw(ruby, hash, "max_decoded_size_bytes") {
+        cfg.max_decoded_size_bytes = u64::try_convert(limit)?;
+    }
+
+    if let Some(prefix) = get_kw(ruby, hash, "filename_prefix") {
+        cfg.filename_prefix = if prefix.is_nil() {
+            None
+        } else {
+            Some(String::try_convert(prefix)?)
+        };
+    }
+
+    if let Some(capture_svg) = get_kw(ruby, hash, "capture_svg") {
+        cfg.capture_svg = bool::try_convert(capture_svg)?;
+    }
+
+    if let Some(infer_dimensions) = get_kw(ruby, hash, "infer_dimensions") {
+        cfg.infer_dimensions = bool::try_convert(infer_dimensions)?;
+    }
+
+    Ok(cfg)
+}
+
+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 = match format {
+        InlineImageFormat::Png => "png".to_string(),
+        InlineImageFormat::Jpeg => "jpeg".to_string(),
+        InlineImageFormat::Gif => "gif".to_string(),
+        InlineImageFormat::Bmp => "bmp".to_string(),
+        InlineImageFormat::Webp => "webp".to_string(),
+        InlineImageFormat::Svg => "svg".to_string(),
+        InlineImageFormat::Other(other) => other,
+    };
+    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(width as i64)?;
+        dims.push(height as i64)?;
+        hash.aset(ruby.intern("dimensions"), dims)?;
+    } else {
+        hash.aset(ruby.intern("dimensions"), ruby.qnil())?;
+    }
+
+    let source_value = match source {
+        InlineImageSource::ImgDataUri => "img_data_uri",
+        InlineImageSource::SvgElement => "svg_element",
+    };
+    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())
+}
+
+fn warning_to_value(ruby: &Ruby, warning: InlineImageWarning) -> Result<Value, Error> {
+    let hash = ruby.hash_new();
+    hash.aset(ruby.intern("index"), warning.index as i64)?;
+    hash.aset(ruby.intern("message"), warning.message)?;
+    Ok(hash.as_value())
+}
+
+fn extraction_to_value(ruby: &Ruby, extraction: HtmlExtraction) -> Result<Value, Error> {
+    let hash = ruby.hash_new();
+    hash.aset(ruby.intern("markdown"), extraction.markdown)?;
+
+    let inline_images = ruby.ary_new();
+    for image in extraction.inline_images {
+        inline_images.push(inline_image_to_value(ruby, image)?)?;
+    }
+    hash.aset(ruby.intern("inline_images"), inline_images)?;
+
+    let warnings = ruby.ary_new();
+    for warning in extraction.warnings {
+        warnings.push(warning_to_value(ruby, warning)?)?;
+    }
+    hash.aset(ruby.intern("warnings"), warnings)?;
+
+    Ok(hash.as_value())
+}
+
+fn convert_fn(ruby: &Ruby, args: &[Value]) -> Result<String, Error> {
+    let parsed = scan_args::<(String,), (Option<Value>,), (), (), (), ()>(args)?;
+    let html = parsed.required.0;
+    let options = build_conversion_options(ruby, parsed.optional.0)?;
+
+    convert_inner(&html, Some(options)).map_err(conversion_error)
+}
+
+fn convert_with_inline_images_fn(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
+    let parsed = scan_args::<(String,), (Option<Value>, Option<Value>), (), (), (), ()>(args)?;
+    let html = parsed.required.0;
+    let options = build_conversion_options(ruby, parsed.optional.0)?;
+    let config = build_inline_image_config(ruby, parsed.optional.1)?;
+
+    let extraction = convert_with_inline_images_inner(&html, Some(options), config).map_err(conversion_error)?;
+
+    extraction_to_value(ruby, extraction)
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("HtmlToMarkdown")?;
+    module.define_singleton_method("convert", function!(convert_fn, -1))?;
+    module.define_singleton_method(
+        "convert_with_inline_images",
+        function!(convert_with_inline_images_fn, -1),
+    )?;
+
+    Ok(())
+}

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: html-to-markdown
+version: !ruby/object:Gem::Version
+  version: 2.5.1
+platform: ruby
+authors:
+- Na'aman Hirschfeld
+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'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: High-performance HTML to Markdown conversion from Ruby using Magnus and
+  rb-sys.
+email:
+- nhirschfeld@gmail.com
+executables:
+- html-to-markdown
+extensions:
+- extconf.rb
+extra_rdoc_files: []
+files:
+- Cargo.toml
+- README.md
+- exe/html-to-markdown
+- extconf.rb
+- lib/bin/html-to-markdown
+- lib/html_to_markdown.rb
+- lib/html_to_markdown/cli.rb
+- lib/html_to_markdown/cli_proxy.rb
+- lib/html_to_markdown/version.rb
+- spec/cli_proxy_spec.rb
+- spec/convert_spec.rb
+- spec/spec_helper.rb
+- src/lib.rs
+homepage: https://github.com/Goldziher/html-to-markdown
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/Goldziher/html-to-markdown
+  source_code_uri: https://github.com/Goldziher/html-to-markdown
+  bug_tracker_uri: https://github.com/Goldziher/html-to-markdown/issues
+  changelog_uri: https://github.com/Goldziher/html-to-markdown/releases
+  documentation_uri: https://github.com/Goldziher/html-to-markdown/blob/main/README.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Ruby bindings for the html-to-markdown Rust library
+test_files: []