sghtmltopdf 0.1.0-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 76c5e09cd07d909ef74f7b5c2c56ea163f16dd407e2d309238ac0932309e9528
+  data.tar.gz: 56498f8925b1e32b11d919b77620886cf7c39287d55d3fdeb6547e84e9bf35a6
+SHA512:
+  metadata.gz: cc27feea209ad21fc3af19e4d3e0aac98039bf004ef6a21f42f18b8888af56a9390a491ebfc1a8e45482b545a9f3e7c258b5216ee162c9f7df4248276c6fd6d3
+  data.tar.gz: cc1033fec212e7a14c8a6f66da6f0d6cb2d257a1fd27d13d60b1bb6f59039ba73e211ce2db6b913a633dc9472f1f58e2a9c624785aacd5e5178323ee1a771154

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yo_waka
+
+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,109 @@
+# sghtmltopdf
+
+Ruby binding for [sghtmltopdf](https://github.com/waka/sghtmltopdf), an HTML-to-PDF renderer written in Rust that does not depend on Chromium, WebKit, or Gecko.
+
+The engine runs inside your process through a native extension (magnus + rb-sys) — no subprocess, no temporary files — and releases the GVL while rendering, so other Puma threads keep running.
+
+[Documentation](https://waka.github.io/sghtmltopdf/en/usage/ruby_rails.html) · [Repository](https://github.com/waka/sghtmltopdf) · [CHANGELOG](https://github.com/waka/sghtmltopdf/blob/main/CHANGELOG.md)
+
+## Install
+
+```ruby
+# Gemfile
+gem "sghtmltopdf"
+```
+
+Precompiled native gems are published for `x86_64-linux`, `aarch64-linux`, `x86_64-linux-musl`, `aarch64-linux-musl`, and `arm64-darwin`.
+There is no build step on those platforms.
+
+Elsewhere (Intel Mac, Windows) the gem cannot run in-process — the source gem does not carry the Rust core and will refuse to build with an explanatory message.
+Point those environments at a separate `sghtmltopdf server` process instead; see [Delegating to a server](#delegating-to-a-server).
+
+Requires Ruby >= 3.2.
+
+## Usage
+
+```ruby
+pdf = Sghtmltopdf.render("<h1>Invoice</h1>", page_size: "A4", margin_top: "20mm")
+```
+
+Option names are the CLI long options without `--` and with `-` replaced by `_`, so `--page-size A4` becomes `page_size: "A4"`.
+The [option reference](https://waka.github.io/sghtmltopdf/en/usage/cli/reference.html) lists all of them.
+
+Write straight to a file (written to a temporary file and renamed on success, so a failure never leaves a broken PDF behind), or take the bytes in chunks:
+
+```ruby
+Sghtmltopdf.render_to_file(html, "invoice.pdf", page_size: "A4")
+
+Sghtmltopdf.render(html) { |bytes| io.write(bytes) }
+```
+
+## Rails
+
+Adding the gem is enough; the Railtie wires everything up, and nothing is loaded when Rails is absent.
+
+```ruby
+# config/initializers/sghtmltopdf.rb
+Sghtmltopdf.configure do |c|
+  c.page_size   = "A4"
+  c.gothic_font = Rails.root.join("vendor/fonts/NotoSansJP-Regular.ttf")
+end
+```
+
+A `:pdf` renderer is registered, in the spirit of [wicked_pdf](https://github.com/mileszs/wicked_pdf) — the same keys, so an existing controller often needs no change at all:
+
+```ruby
+class InvoicesController < ApplicationController
+  def show
+    render pdf: "invoice",              # filename; ".pdf" is appended
+      template: "invoices/show",
+      layout: "pdf",
+      page_size: "A4", margin_top: "20mm"
+  end
+end
+```
+
+View-rendering keys (`template`, `layout`, `locals`, …) go to `render_to_string`, response keys (`filename`, `disposition`, `status`) go to `send_data`, `show_as_html: true` returns the HTML instead of a PDF, and everything else is passed to the converter.
+Converter keys are flat CLI flag names, so wicked_pdf's nested `margin: {top: 10}` becomes `margin_top: "10mm"` (with the unit spelled out); the [migration guide](https://waka.github.io/sghtmltopdf/en/migration/wicked-pdf.html) maps every key one by one.
+
+### Assets
+
+PDF rendering does not go through the HTTP server, so `/assets/…` URLs are resolved as local files: the Railtie defaults `base_url` to `Rails.root/public` and restricts local reads to `Rails.root` via `allow`.
+That is enough for a precompiled production app; in development, these helpers inline the asset instead:
+
+```erb
+<%= sghtmltopdf_stylesheet_link_tag "pdf" %>
+<%= sghtmltopdf_image_tag "logo.png" %>
+```
+
+### Streaming the response
+
+To send pages as soon as their layout is final, pass a block and use `ActionController::Live` — this also makes `Rack::Timeout` and `Thread#kill` effective at chunk boundaries:
+
+```ruby
+class InvoicesController < ApplicationController
+  include ActionController::Live
+
+  def show
+    response.headers["Content-Type"] = "application/pdf"
+    html = render_to_string(template: "invoices/show", layout: "pdf")
+    Sghtmltopdf.render(html) { |bytes| response.stream.write(bytes) }
+  ensure
+    response.stream.close
+  end
+end
+```
+
+## Delegating to a server
+
+If the gem cannot run where your app runs, or you would rather not spend the app's CPU on rendering, set `server_url` and the same calls are delegated over HTTP to a separate `sghtmltopdf server` process.
+
+```ruby
+Sghtmltopdf.configure { |c| c.server_url = "http://pdf:8080" }
+```
+
+The [official Docker image](https://waka.github.io/sghtmltopdf/en/getting-started/docker.html) runs that server and bundles Japanese fonts.
+
+## License
+
+MIT License ([LICENSE](LICENSE)).

data/lib/sghtmltopdf/configuration.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Sghtmltopdf
+  # グローバルな既定オプション。
+  #
+  #   Sghtmltopdf.configure do |c|
+  #     c.page_size   = "A4"
+  #     c.gothic_font = "/path/to/NotoSansJP-Regular.ttf"
+  #   end
+  #
+  # ここで設定した値は`render`/`render_to_file`の引数で上書きできる
+  # (マージ順はグローバル → 呼び出し時)。
+  #
+  # キー名の妥当性は検査しない。オプション定義はRust側(`cli/options.rs`)の
+  # 1箇所に集約する方針のため、未知のキーはレンダリング時にclapが`UsageError`をraiseする。
+  class Configuration
+    def initialize(options = {})
+      @options = {}
+      # 明示的に設定した値(@options)と、Railtieなどが流し込んだ既定値
+      # (@defaults)は分けて持つ。読み出しは常に@optionsが勝つので、
+      # イニシャライザの実行順に依存しない。
+      @defaults = {}
+      options.each { |key, value| self[key] = value }
+    end
+
+    def [](key)
+      key = key.to_sym
+      @options.key?(key) ? @options[key] : @defaults[key]
+    end
+
+    def []=(key, value)
+      @options[key.to_sym] = value
+    end
+
+    # @param with_defaults [Boolean] 流し込まれた既定値を含めるか。
+    #   HTTPサーバへ委譲するときは`false`にする。Rails向けの既定値
+    #   (`base_url`・`allow`)はローカルのファイル解決のためのもので、
+    #   サーバモードではリクエストから指定できないキーだから
+    def to_h(with_defaults: true)
+      with_defaults ? @defaults.merge(@options) : @options.dup
+    end
+
+    # 既定値を流し込む。Railtieが Rails向けの既定値を入れるのに使う。
+    # 明示的に設定された値より弱い(順序に関係なく`[]=`が勝つ)。
+    def apply_defaults(defaults)
+      defaults.each { |key, value| @defaults[key.to_sym] = value }
+      self
+    end
+
+    # `c.page_size = "A4"`と`c.page_size`を受ける。
+    def method_missing(name, *args)
+      key = name.to_s
+      if key.end_with?("=")
+        raise ArgumentError, "#{name}は引数1つを取ります" unless args.size == 1
+
+        self[key.chomp("=")] = args.first
+      else
+        raise ArgumentError, "#{name}は引数を取りません" unless args.empty?
+
+        self[key]
+      end
+    end
+
+    def respond_to_missing?(_name, _include_private = false)
+      true
+    end
+  end
+end

data/lib/sghtmltopdf/options.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Sghtmltopdf
+  # オプションハッシュを変換する。
+  #
+  # * ネイティブ拡張へ渡すCLIの引数列(argv) … [.to_argv]
+  # * HTTPサーバモードへ渡すクエリ文字列   … [.to_query]
+  module Options
+    # 入力は常に標準入力を表す`-`を置く(実際のバイト列はFFIで直接渡すため
+    # 読まれない)。出力先はRust側のSinkが決めるので、ここもダミーの`-`。
+    # `-`入力のときCLIは`--output`を必須にするため、省略はできない。
+    ARGV_PREFIX = ["sghtmltopdf", "-", "--output", "-"].freeze
+
+    # Ruby側だけで解釈するキー。変換オプションではないので、argvにも
+    # クエリにも出さない。
+    TRANSPORT_KEYS = %i[server_url server_open_timeout server_read_timeout chunk_size].freeze
+
+    module_function
+
+    # @param options [Hash] Rubyのオプションハッシュ
+    # @return [Array<String>] clapへ渡す引数列
+    def to_argv(options)
+      argv = ARGV_PREFIX.dup
+      each_pair(options) do |name, value|
+        argv.push("--#{name}")
+        argv.push(value) unless value.nil?
+      end
+      argv
+    end
+
+    # @param options [Hash] Rubyのオプションハッシュ
+    # @return [String] `POST /pdf`のクエリ文字列(先頭に`?`は付けない)
+    def to_query(options)
+      parts = []
+      each_pair(options) do |name, value|
+        # 値なしのフラグはキーだけを置く(サーバは値なし＝真として扱う)。
+        parts << (value.nil? ? escape(name) : "#{escape(name)}=#{escape(value)}")
+      end
+      parts.join("&")
+    end
+
+    # 1つのキーと値をargvの断片へ変換する。
+    #
+    #   page_size: "A4"     → ["--page-size", "A4"]
+    #   grayscale: true     → ["--grayscale"]
+    #   grayscale: false    → []
+    #   allow: ["/a", "/b"] → ["--allow", "/a", "--allow", "/b"]
+    def args_for(key, value)
+      pairs_for(key, value).flat_map { |name, arg| arg.nil? ? ["--#{name}"] : ["--#{name}", arg] }
+    end
+
+    # 1つのキーと値を「フラグ名と値」のペアの列にする。値が`nil`のペアは
+    # 値を取らないフラグ(`--toc`など)。
+    def pairs_for(key, value)
+      name = flag_name(key)
+      return font_pairs(value) if name == "font"
+
+      case value
+      when nil, false then []
+      when true then [[name, nil]]
+      # 配列は同じオプションの繰り返し。要素ごとに同じ規則を適用する。
+      when Array then value.flat_map { |element| pairs_for(key, element) }
+      when Hash
+        # wicked_pdfの`margin: {top: 10}`のような入れ子は受けない。数値の
+        # 単位の解釈が違う(wicked_pdfはmm・こちらはpx)ため、機械的に
+        # 平坦化すると黙って別の余白になる。移行時は
+        # 移行ガイドの対応表を見て書き換えてもらう。
+        example = value.keys.first
+        raise ArgumentError,
+          "#{key}にHashは渡せません(pathとindexを取るのは:fontだけです)。" \
+          "入れ子のオプションは平坦なキーで指定してください" \
+          "#{": 例 #{key}_#{example}: \"…\"" if example}"
+      else [[name, value.to_s]]
+      end
+    end
+
+    # `--font`と`--font-index`は出現順で対応付けられる(CLIは
+    # `ArgMatches#indices_of`で「`--font-index`より手前にある最後の`--font`」
+    # へ結び付ける)。そのため、フェイス番号は
+    # 必ず対応する`--font`の直後へ置く。
+    #
+    #   font: "a.ttf"                        → ["--font", "a.ttf"]
+    #   font: {path: "a.ttc", index: 1}      → ["--font", "a.ttc", "--font-index", "1"]
+    #   font: ["a.ttf", {path: "b.ttc", index: 2}]
+    #     → ["--font", "a.ttf", "--font", "b.ttc", "--font-index", "2"]
+    def font_args(value)
+      font_pairs(value).flat_map { |name, arg| ["--#{name}", arg] }
+    end
+
+    def font_pairs(value)
+      case value
+      when nil, false then []
+      when Array then value.flat_map { |element| font_pairs(element) }
+      when Hash
+        path = value[:path] || value["path"]
+        raise ArgumentError, "fontのHashにはpathが必要です: #{value.inspect}" if path.nil?
+
+        index = value[:index] || value["index"]
+        pairs = [["font", path.to_s]]
+        pairs << ["font-index", index.to_s] unless index.nil?
+        pairs
+      else [["font", value.to_s]]
+      end
+    end
+
+    # `:page_size` → `page-size`。
+    def flag_name(key)
+      key.to_s.tr("_", "-")
+    end
+
+    # 変換オプションだけを、渡された順にペアとして列挙する。
+    def each_pair(options, &block)
+      options.each do |key, value|
+        next if TRANSPORT_KEYS.include?(key.to_sym)
+
+        pairs_for(key, value).each(&block)
+      end
+    end
+
+    def escape(value)
+      URI.encode_www_form_component(value.to_s)
+    end
+  end
+end

data/lib/sghtmltopdf/railtie.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+require_relative "renderer"
+require_relative "view_helpers"
+
+module Sghtmltopdf
+  class Railtie < ::Rails::Railtie
+    def self.default_options(root)
+      root = root.to_s
+      defaults = {allow: [root]}
+      public_dir = File.join(root, "public")
+      defaults[:base_url] = public_dir if File.directory?(public_dir)
+      defaults
+    end
+
+    initializer "sghtmltopdf.defaults" do |app|
+      Sghtmltopdf.config.apply_defaults(Sghtmltopdf::Railtie.default_options(app.root))
+    end
+
+    initializer "sghtmltopdf.renderer" do
+      ActiveSupport.on_load(:action_controller) do
+        Sghtmltopdf::Renderer.register!
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        include Sghtmltopdf::ViewHelpers
+      end
+    end
+  end
+end

data/lib/sghtmltopdf/renderer.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Sghtmltopdf
+  # `render pdf: "invoice"`のオプションを、
+  #
+  # * Railsのビュー描画(`render_to_string`)へ渡すもの
+  # * レスポンスの組み立て(`send_data`)へ渡すもの
+  # * PDF変換(`Sghtmltopdf.render`)へ渡すもの
+  #
+  # の3つに振り分ける。
+  # Railsに依存しないpure Rubyのクラスなので、Rails無しでも単体テストできる。
+  class Renderer
+    # `render_to_string`へそのまま渡すキー。
+    RAILS_RENDER_KEYS = %i[
+      action assigns body collection file formats handlers html inline layout
+      locals object partial plain prefixes template variants
+    ].freeze
+
+    # レスポンスの組み立てに使うキー(`send_data`へ渡す)。
+    RESPONSE_KEYS = %i[disposition filename status].freeze
+
+    # レンダラ自身が解釈するキー(PDFにせずHTMLのまま返すデバッグ用)。
+    RENDERER_KEYS = %i[show_as_html].freeze
+
+    PDF_CONTENT_TYPE = "application/pdf"
+    HTML_CONTENT_TYPE = "text/html"
+
+    attr_reader :name, :options
+
+    # @param name [String, Symbol, nil] `pdf:`に渡された値(ファイル名の素)
+    # @param options [Hash] `render`に渡されたその他のオプション
+    # @param default_name [String, nil] `name`が空のときのファイル名
+    #   (コントローラの`action_name`を想定)
+    def initialize(name, options = {}, default_name: nil)
+      @name = blank?(name) ? (default_name || "document").to_s : name.to_s
+      @options = options.to_h { |key, value| [key.to_sym, value] }
+    end
+
+    # `ActionController::Renderers.add(:pdf)`でレンダラを登録する。
+    # RailtieのAction Controller読み込みフック(`on_load`)から呼ぶ。
+    def self.register!
+      ::ActionController::Renderers.add(:pdf) do |name, options|
+        renderer = ::Sghtmltopdf::Renderer.new(name, options, default_name: action_name)
+        html = render_to_string(**renderer.render_options)
+        send_data(renderer.body_for(html), **renderer.send_data_options)
+      end
+    end
+
+    # ビューの描画に使うオプション。
+    def render_options
+      options.select { |key, _| RAILS_RENDER_KEYS.include?(key) }
+    end
+
+    # PDF変換に使うオプション。
+    def convert_options
+      known = RAILS_RENDER_KEYS + RESPONSE_KEYS + RENDERER_KEYS
+      options.reject { |key, _| known.include?(key) }
+    end
+
+    # 描画したHTMLをレスポンスの本文へ変換する。
+    def body_for(html)
+      show_as_html? ? html : Sghtmltopdf.render(html, **convert_options)
+    end
+
+    def send_data_options
+      opts = {type: content_type, disposition: disposition}
+      opts[:filename] = filename unless show_as_html?
+      opts[:status] = options[:status] if options.key?(:status)
+      opts
+    end
+
+    def content_type
+      show_as_html? ? HTML_CONTENT_TYPE : PDF_CONTENT_TYPE
+    end
+
+    # `filename: "x.pdf"` > `pdf: "x"` の順。拡張子は二重に付けない。
+    def filename
+      base = blank?(options[:filename]) ? name : options[:filename].to_s
+      base.downcase.end_with?(".pdf") ? base : "#{base}.pdf"
+    end
+
+    # wicked_pdfと同じく既定は`inline`(ブラウザ内で開く)。
+    def disposition
+      blank?(options[:disposition]) ? "inline" : options[:disposition].to_s
+    end
+
+    # wicked_pdfの`show_as_html`相当。PDFにせずHTMLをそのまま返すので、
+    # ブラウザの開発者ツールでレイアウトを確認できる。
+    def show_as_html?
+      value = options[:show_as_html]
+      !(value.nil? || value == false || value == "false")
+    end
+
+    private
+
+    def blank?(value)
+      value.nil? || (value.respond_to?(:empty?) && value.empty?)
+    end
+  end
+end

data/lib/sghtmltopdf/server_client.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Sghtmltopdf
+  class ServerError < Error; end
+
+  # HTTPサーバモード(`sghtmltopdf server`)へ変換を委譲するクライアント。
+  #
+  #   Sghtmltopdf.configure { |c| c.server_url = "http://pdf.internal:8080" }
+  #   pdf = Sghtmltopdf.render(html, page_size: "A4")
+  class ServerClient
+    DEFAULT_OPEN_TIMEOUT = 5
+    DEFAULT_READ_TIMEOUT = 120
+
+    # 一度に読むチャンクの目安。`?stream=1`のときはこの単位でブロックへ渡る。
+    CHUNK_SIZE = 64 * 1024
+
+    attr_reader :uri, :open_timeout, :read_timeout
+
+    # @param url [String] サーバのベースURL(`http://host:port`)
+    def initialize(url, open_timeout: nil, read_timeout: nil)
+      @uri = parse(url)
+      @open_timeout = (open_timeout || DEFAULT_OPEN_TIMEOUT).to_f
+      @read_timeout = (read_timeout || DEFAULT_READ_TIMEOUT).to_f
+    end
+
+    # HTMLをPDFへ変換する。
+    #
+    # ブロックを渡すと`?stream=1`(chunked transfer encoding)を使い、
+    # サーバがページを確定したそばからチャンクを渡す。ブロックが無ければ
+    # PDF全体をStringで返す。
+    def render(html, options, &block)
+      request = build_request(html, options, stream: !block.nil?)
+      pdf = nil
+      start do |http|
+        # `request`はブロック付きだとレスポンスオブジェクトを返すので、
+        # 結果は外の変数で受ける。
+        http.request(request) do |response|
+          ensure_success!(response)
+          if block
+            response.read_body { |chunk| block.call(chunk.b) }
+          else
+            pdf = read_all(response)
+          end
+        end
+      end
+      pdf
+    end
+
+    # 変換結果を`path`へ書き出す。途中で失敗しても壊れたPDFを残さないよう、
+    # 一時ファイルへ書いてからrenameする(ネイティブ拡張の`FileSink`と同じ
+    # 挙動に揃えている)。
+    def render_to_file(html, options, path)
+      tmp = "#{path}.#{Process.pid}.tmp"
+      begin
+        File.open(tmp, "wb") do |file|
+          render(html, options) { |chunk| file.write(chunk) }
+        end
+      rescue SystemCallError => e
+        File.unlink(tmp) if File.exist?(tmp)
+        raise InputError, "#{path}への書き出しに失敗しました: #{e.message}"
+      rescue StandardError
+        File.unlink(tmp) if File.exist?(tmp)
+        raise
+      end
+      File.rename(tmp, path)
+      nil
+    end
+
+    private
+
+    def parse(url)
+      uri = URI.parse(url.to_s)
+      unless uri.is_a?(URI::HTTP) && uri.host
+        raise ArgumentError, "server_urlにはhttp(s)のURLを指定してください: #{url.inspect}"
+      end
+
+      uri
+    end
+
+    def build_request(html, options, stream:)
+      query = Options.to_query(options)
+      query = stream ? [query, "stream=1"].reject(&:empty?).join("&") : query
+      target = uri.dup
+      target.path = "/pdf"
+      target.query = query.empty? ? nil : query
+
+      request = Net::HTTP::Post.new(target)
+      request["Content-Type"] = "text/html; charset=utf-8"
+      request.body = html.to_s.b
+      request
+    end
+
+    def start(&block)
+      Net::HTTP.start(
+        uri.host, uri.port,
+        use_ssl: uri.scheme == "https",
+        open_timeout: open_timeout,
+        read_timeout: read_timeout,
+        &block
+      )
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise ServerError, "#{base}への接続がタイムアウトしました: #{e.class}"
+    rescue SocketError, SystemCallError, IOError, OpenSSL::SSL::SSLError => e
+      raise ServerError, "#{base}への接続に失敗しました: #{e.message}"
+    end
+
+    # エラー応答の本文は`text/plain`の日本語メッセージ(CLIと同じ文言)。
+    def ensure_success!(response)
+      return if response.is_a?(Net::HTTPOK)
+
+      message = read_all(response).force_encoding(Encoding::UTF_8).strip
+      raise error_class(response), "#{base}: #{message}"
+    end
+
+    def error_class(response)
+      case response.code.to_i
+      when 400 then UsageError
+      when 413 then InputError
+      when 500 then RenderError
+      # 404/405はパスやメソッドの間違い＝相手がsghtmltopdfのサーバでない
+      # 可能性が高い。503/504はキュー溢れ・キュー待ちのタイムアウト。
+      else ServerError
+      end
+    end
+
+    def read_all(response)
+      buffer = +""
+      response.read_body { |chunk| buffer << chunk }
+      buffer.b
+    end
+
+    def base
+      "#{uri.scheme}://#{uri.host}:#{uri.port}"
+    end
+  end
+end

data/lib/sghtmltopdf/version.rb

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

data/lib/sghtmltopdf/view_helpers.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Sghtmltopdf
+  # Action View用のヘルパ。
+  #
+  # PDFのレンダリングはHTTPサーバを介さないため、`/assets/…`のようなURLは
+  # ローカルファイルとして解決される(`--base-url`の既定は
+  # `Rails.root/public`。[Railtie.default_options])。precompile済みの
+  # 本番環境ではこれで素の`stylesheet_link_tag`もそのまま動くが、開発環境の
+  # ようにアセットがまだ`public/`へ書き出されていない場合は解決できない。
+  #
+  # そこで、
+  #
+  #   <%= sghtmltopdf_stylesheet_link_tag "pdf" %>
+  #
+  # のようにCSSの中身を`<style>`へ展開するヘルパを用意する(wicked_pdfの
+  # `wicked_pdf_stylesheet_link_tag`に相当)。
+  module ViewHelpers
+    # アセットのローカルファイルパスを返す。見つからなければ`nil`。
+    #
+    # 1. `public/`配下(precompile済み。本番環境)
+    # 2. アセットパイプラインのロードパス(開発環境。Propshaft/Sprockets)
+    #
+    # の順に探す。パイプラインの参照はどちらのgemにも依存しないよう
+    # `respond_to?`で分岐している(best effort)。
+    def sghtmltopdf_asset_path(source)
+      path = source.to_s
+      return path if path.start_with?("/") && File.file?(path)
+
+      from_public_dir(path) || from_asset_pipeline(path)
+    end
+
+    # CSSの中身を`<style>`へ展開する。複数指定でき、見つからないものは
+    # 黙って飛ばす(PDF生成そのものは止めない)。
+    def sghtmltopdf_stylesheet_link_tag(*sources)
+      css = sources.flatten.filter_map do |source|
+        path = sghtmltopdf_asset_path(with_extension(source, ".css"))
+        File.read(path) if path
+      end
+      return "".html_safe if css.empty?
+
+      content_tag(:style, css.join("\n").html_safe, type: "text/css")
+    end
+
+    # `image_tag`のsrcをローカルファイルパスへ差し替える。
+    def sghtmltopdf_image_tag(source, options = {})
+      image_tag(sghtmltopdf_asset_path(source) || source, options)
+    end
+
+    private
+
+    # `asset_path`が返すURL(asset_hostが付くこともある)からパス部分だけを
+    # 取り出し、`public/`配下の実ファイルへ対応付ける。
+    def from_public_dir(source)
+      url = respond_to?(:asset_path) ? asset_path(source) : source
+      relative = url.to_s.sub(%r{\Ahttps?://[^/]+}, "").split(/[?#]/).first.to_s
+      return nil if relative.empty?
+
+      candidate = File.join(::Rails.public_path.to_s, relative)
+      File.file?(candidate) ? candidate : nil
+    end
+
+    def from_asset_pipeline(source)
+      assets = ::Rails.application.try(:assets)
+      return nil if assets.nil?
+
+      # Propshaft
+      if assets.respond_to?(:load_path)
+        found = assets.load_path.find(source)
+        return found.path.to_s if found.respond_to?(:path)
+      end
+      # Sprockets
+      if assets.respond_to?(:[])
+        found = assets[source]
+        return found.filename.to_s if found.respond_to?(:filename)
+      end
+      nil
+    end
+
+    def with_extension(source, extension)
+      name = source.to_s
+      name.end_with?(extension) ? name : "#{name}#{extension}"
+    end
+  end
+end

data/lib/sghtmltopdf.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "sghtmltopdf/version"
+require_relative "sghtmltopdf/options"
+require_relative "sghtmltopdf/configuration"
+require_relative "sghtmltopdf/renderer"
+
+# precompiled gemはRubyのマイナーバージョンごとのディレクトリへ`.so`を置く
+# (rake-compilerのクロスビルドの慣習)。開発中の`rake compile`は
+# `lib/sghtmltopdf/sghtmltopdf.so`に置くので、両方を試す。
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "sghtmltopdf/#{Regexp.last_match(1)}/sghtmltopdf"
+rescue LoadError
+  require "sghtmltopdf/sghtmltopdf"
+end
+
+# `Error`(ネイティブ拡張が定義)を継承するため、拡張の読み込みより後に書く。
+require_relative "sghtmltopdf/server_client"
+
+module Sghtmltopdf
+  # ブロック付き`render`で1回に渡すバイト数の目安(ローカル変換のみ)。
+  # ページ確定ごとにブロックを呼ぶとGVLの取り直しが増えるため、ここまで
+  # 溜めてから渡す。
+  DEFAULT_CHUNK_SIZE = 64 * 1024
+
+  class << self
+    # HTMLを変換してPDFのバイト列(ASCII-8BITのString)を返す。
+    #
+    # ブロックを渡すと、PDF全体を組み立ててから返す代わりにチャンクごとに
+    # ブロックを呼ぶ(返り値はnil)。Rackの`response.stream`へ流したり、S3の
+    # マルチパートアップロードへ繋いだりするための口(エンジン側は出力先(sink)
+    # を意識しない設計に対応する)。
+    #
+    #   Sghtmltopdf.render(html) { |bytes| response.stream.write(bytes) }
+    #
+    # ローカル・サーバ委譲のどちらでも、PDF全体が組み上がるのを待たずに
+    # 書き出せる(ローカルは確定したページから順に、サーバは`?stream=1`の
+    # chunked transfer encodingをそのまま渡す)。
+    #
+    # ただし逐次になるのはPDFの書き出しだけで、HTMLのパースとレイアウトは
+    # 文書全体に対して先に行う。最初のチャンクが届くのは変換の終盤で、
+    # ピークメモリもブロック無しの場合と変わらない。HTMLを読みながら
+    # ページを確定させたい場合は`streaming: true`と併せて使う
+    # (制約と引き換えにメモリが大きく減る)。
+    #
+    # 1回に渡すバイト数の目安は`chunk_size:`で変えられる(既定64KiB。
+    # ローカル変換のみ。小さくするとGVLの取り直しが増える)。
+    def render(html, **options, &block)
+      client = server_client(options)
+      return client.render(html.to_s, server_options(options), &block) if client
+      return Native.render(html.to_s, argv_for(options)) if block.nil?
+
+      Native.render_each(html.to_s, argv_for(options), block, chunk_size(options))
+      nil
+    end
+
+    # HTMLを変換して`path`へ書き出す。
+    #
+    # 一時ファイルへ書いて成功時だけrenameするため、途中で失敗しても
+    # 壊れたPDFが出力先に残らない(サーバへ委譲する場合も同じ)。
+    def render_to_file(html, path, **options)
+      client = server_client(options)
+      return client.render_to_file(html.to_s, server_options(options), path.to_s) if client
+
+      Native.render_to_file(html.to_s, argv_for(options), path.to_s)
+      nil
+    end
+
+    # グローバルな既定オプション。
+    def configure
+      yield config
+      config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    # 主にテスト用。設定を空に戻す。
+    def reset_config!
+      @config = Configuration.new
+    end
+
+    private
+
+    # グローバル設定 → 呼び出し時オプションの順にマージしてargvにする。
+    def argv_for(options)
+      Options.to_argv(config.to_h.merge(options))
+    end
+
+    # `server_url`があればサーバへ委譲する。タイムアウトも同じ順でマージする。
+    def server_client(options)
+      merged = config.to_h.merge(options)
+      url = merged[:server_url]
+      return nil if url.nil? || url.to_s.empty?
+
+      ServerClient.new(
+        url,
+        open_timeout: merged[:server_open_timeout],
+        read_timeout: merged[:server_read_timeout]
+      )
+    end
+
+    # ブロックへ1回に渡すバイト数の目安(ローカル変換のみ)。
+    def chunk_size(options)
+      value = config.to_h.merge(options)[:chunk_size]
+      value.nil? ? DEFAULT_CHUNK_SIZE : Integer(value)
+    end
+
+    # サーバへ渡すオプション。流し込まれた既定値は外す
+    # (Rails向けの`base_url`・`allow`はローカルのファイル解決のための
+    # 既定値で、サーバモードではリクエストから指定できず400になる。
+    # 明示的に設定した値はそのまま送り、可否はサーバに判断させる)。
+    def server_options(options)
+      config.to_h(with_defaults: false).merge(options)
+    end
+  end
+end
+
+require_relative "sghtmltopdf/railtie" if defined?(::Rails::Railtie)

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: sghtmltopdf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: aarch64-linux
+authors:
+- yo_waka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-08-08 00:00:00.000000000 Z
+dependencies: []
+description: |
+  wkhtmltopdfの後継として、Chromium/WebKit/Geckoに依存しないRust製の
+  HTML→PDFレンダリングエンジンをRubyから使うためのバインディング。
+  Railsからはwicked_pdf互換のレンダラ(`render pdf: "invoice"`)で使える。
+email:
+- y.wakahara@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/sghtmltopdf.rb
+- lib/sghtmltopdf/3.0/sghtmltopdf.so
+- lib/sghtmltopdf/3.1/sghtmltopdf.so
+- lib/sghtmltopdf/3.2/sghtmltopdf.so
+- lib/sghtmltopdf/3.3/sghtmltopdf.so
+- lib/sghtmltopdf/3.4/sghtmltopdf.so
+- lib/sghtmltopdf/4.0/sghtmltopdf.so
+- lib/sghtmltopdf/configuration.rb
+- lib/sghtmltopdf/options.rb
+- lib/sghtmltopdf/railtie.rb
+- lib/sghtmltopdf/renderer.rb
+- lib/sghtmltopdf/server_client.rb
+- lib/sghtmltopdf/version.rb
+- lib/sghtmltopdf/view_helpers.rb
+homepage: https://github.com/waka/sghtmltopdf
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/waka/sghtmltopdf
+  changelog_uri: https://github.com/waka/sghtmltopdf/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/waka/sghtmltopdf/issues
+  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.0'
+  - - "<"
+    - !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: Chromium/WebKit/Geckoに依存しないHTML→PDFレンダラー
+test_files: []