html-to-markdown 2.5.3-x64-mingw-ucrt

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3edeb66ccdc89e17be9432b3d65ae1048afa0563c9f2844fd93dceb63dbbb41b
+  data.tar.gz: 256c1d843f273cefaae7e9412b76b1cbc2193cd06b1fad96ba7a9a1b511c1a8a
+SHA512:
+  metadata.gz: 6b2bd69d510e0755b7ced7634bd56fec6302690941c59cca67774ffeffccf63d2e303c0f74149ad8348ed54a16df788710575ef53dc7cf78872ce30838929912
+  data.tar.gz: 02d9c9f2a2e962c99ee3ce7fe21a19623daa0839f6a42a66ac814edbdacc2f0e75328e4f66ed5849c8a18e54f4f75bf2ee9935262a05318528dd981c70c8af1c

data/README.md

@@ -0,0 +1,149 @@
+# 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.
+
+[![Crates.io](https://img.shields.io/crates/v/html-to-markdown-rs.svg)](https://crates.io/crates/html-to-markdown-rs)
+[![npm version](https://badge.fury.io/js/html-to-markdown-node.svg)](https://www.npmjs.com/package/html-to-markdown-node)
+[![PyPI version](https://badge.fury.io/py/html-to-markdown.svg)](https://pypi.org/project/html-to-markdown/)
+[![Gem Version](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.3"
+```
+
+### 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/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.3'
+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

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: html-to-markdown
+version: !ruby/object:Gem::Version
+  version: 2.5.3
+platform: x64-mingw-ucrt
+authors:
+- Na'aman Hirschfeld
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-10-29 00:00:00.000000000 Z
+dependencies: []
+description: High-performance HTML to Markdown conversion from Ruby using Magnus and
+  rb-sys.
+email:
+- nhirschfeld@gmail.com
+executables:
+- html-to-markdown
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- exe/html-to-markdown
+- lib/bin/html-to-markdown.exe
+- lib/html_to_markdown.rb
+- lib/html_to_markdown/cli.rb
+- lib/html_to_markdown/cli_proxy.rb
+- lib/html_to_markdown/version.rb
+- lib/html_to_markdown_rb.so
+- spec/cli_proxy_spec.rb
+- spec/convert_spec.rb
+- spec/spec_helper.rb
+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
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.4.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby bindings for the html-to-markdown Rust library
+test_files: []