sghtmltopdf 0.5.0-x86_64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: be743c44f3d6a9529f42786945776b6fec6b0c9e7464a8e527574531dac7c61b
+  data.tar.gz: 4e7912ebd09d433bb3210b1f9e29fadc4d976833901f3174ce5b68b11d08d746
+SHA512:
+  metadata.gz: eba51c210b84553fca1ab9a5de083d9a51e5ab3858e9b4c39edcf28c60cc2cf916242a0e7f7d7ad983010f9538f58c00f3ef2c0b078bb24c7f68aa1c5c1908b9
+  data.tar.gz: ad16642a65b96aeb416b9fdf05eb1e0307c8c61a439c4ceff384abc38963d20724b0acf7cfc5d876f679f0db496bebbb647b40f56811d52de4f35d1c0a7f46d6

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,114 @@
+# 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`, `arm64-darwin`, and `x86_64-darwin`.
+There is no build step on those platforms.
+
+Elsewhere (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 `public/` and the asset pipeline load paths via `allow_path`.
+That is enough for a precompiled production app; in development the digested `/assets/…` path names no file on disk, so these helpers look the asset up in the pipeline instead — the CSS expanded into a `<style>`, the image referenced by the path the engine can read:
+
+```erb
+<%= sghtmltopdf_stylesheet_link_tag "pdf" %>
+<%= sghtmltopdf_image_tag "logo.png" %>
+```
+
+`sghtmltopdf_stylesheet_link_tag` does not copy the CSS verbatim: it points every `url()` at a file the engine can read and splices in every `@import`.
+The asset pipeline rewrites `url()` through `asset_path` while precompiling, which turns a `@font-face` source into a digested `/assets/…` path, or into an absolute URL once `asset_host` is set — neither can be fetched while rendering, and a `@font-face` that fails to load falls back to the engine default rather than to the next `font-family`.
+
+A file `allow_path` does not cover is embedded as a `data:` URI instead, so that it cannot silently vanish from the PDF; pass `inline: true` to embed unconditionally.
+
+### 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 = Options.canonical_key(key)
+      @options.key?(key) ? @options[key] : @defaults[key]
+    end
+
+    def []=(key, value)
+      @options[Options.canonical_key(key)] = 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[Options.canonical_key(key)] = 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,145 @@
+# 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
+
+    # 別名のキー(値は正規名)。CLIは`--allow`を`--allow-path`の別名として
+    # 受けるが、Ruby側は2つのキーのまま持ち回ってはいけない。既定が一方の
+    # キー、呼び出し時の指定がもう一方のキーだと、ハッシュのマージでは
+    # 上書きにならず両方がargvへ出てしまう(同じフラグの繰り返しは
+    # 「置き換え」ではなく「合併」の意味になる)。
+    ALIAS_KEYS = {allow: :allow_path}.freeze
+
+    module_function
+
+    # 別名のキーを正規名へ寄せる。
+    def canonical_key(key)
+      key = key.to_sym
+      ALIAS_KEYS.fetch(key, key)
+    end
+
+    # ハッシュのキーをまとめて正規化する。
+    def canonicalize(options)
+      options.to_h { |key, value| [canonical_key(key), value] }
+    end
+
+    # @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}`のような入れ子は受けない。対応する
+        # CLIフラグが無く、機械的に平坦化すると綴り違いのキーまで黙って
+        # 通ってしまう。移行時は移行ガイドの対応表を見て書き換えてもらう。
+        # なお単位を省いた数値の解釈はwicked_pdfと同じくmm(`cli/units.rs`)。
+        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|
+        key = canonical_key(key)
+        next if TRANSPORT_KEYS.include?(key)
+
+        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,53 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+require_relative "renderer"
+require_relative "view_helpers"
+
+module Sghtmltopdf
+  class Railtie < ::Rails::Railtie
+    # The directories the engine may read from: `public/`, where the
+    # precompiled assets are, plus the asset pipeline load paths, where their
+    # sources are in development. The pipeline paths reach outside `Rails.root`
+    # for the assets a gem or an engine provides, which is why the whole of
+    # `Rails.root` is not a substitute for them.
+    #
+    # `config.assets` raises rather than answering `nil` when no pipeline gem is
+    # installed, hence `try`.
+    def self.default_options(app)
+      public_dir = File.join(app.root.to_s, "public")
+      pipeline = Array(app.config.try(:assets)&.paths).map(&:to_s)
+      allow = [public_dir, *pipeline].select { |dir| File.directory?(dir) }.uniq
+
+      defaults = {}
+      # An empty list would mean "no --allow-path", which is not the same thing as
+      # "allow nothing": it hands the boundary back to `base_url`. Leaving the
+      # key out says that, and says it in one place.
+      defaults[:allow_path] = allow unless allow.empty?
+      defaults[:base_url] = public_dir if File.directory?(public_dir)
+      defaults
+    end
+
+    # 読むのはinitializerの中ではなく`after_initialize`。パイプラインが
+    # `config.assets.paths`を埋めるのは自分のinitializer(Propshaftなら
+    # `propshaft.append_assets_path`)で、そちらの方が後に走るため。
+    #
+    # `config/initializers`より後になるが、`apply_defaults`は明示的に設定した
+    # 値より常に弱いので、ユーザーの設定を踏むことはない。
+    initializer "sghtmltopdf.defaults" do |app|
+      app.config.after_initialize do
+        Sghtmltopdf.config.apply_defaults(Sghtmltopdf::Railtie.default_options(app))
+      end
+    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.5.0"
+end

data/lib/sghtmltopdf/view_helpers.rb

@@ -0,0 +1,405 @@
+# frozen_string_literal: true
+
+module Sghtmltopdf
+  # Action View helpers.
+  #
+  # Rendering a PDF never goes through an HTTP server, so a URL such as
+  # `/assets/…` is resolved as a local file (`--base-url` defaults to
+  # `Rails.root/public`, see [Railtie.default_options]). In production, where
+  # the assets are precompiled, that makes a plain `stylesheet_link_tag` work as
+  # it is; in development, where nothing has been written to `public/` yet, it
+  # cannot be resolved: the digest and the `/assets/` mount point are made up by
+  # the pipeline at request time, so no file of that name is on disk.
+  #
+  # Hence helpers that look the asset up in the pipeline and hand the engine
+  # something it can actually read:
+  #
+  #   <%= sghtmltopdf_stylesheet_link_tag "pdf" %>
+  #   <%= sghtmltopdf_image_tag "logo.png" %>
+  #
+  # (the counterparts of wicked_pdf's `wicked_pdf_stylesheet_link_tag` and
+  # `wicked_pdf_image_tag`).
+  module ViewHelpers
+    # Local file path of an asset, or `nil` when it cannot be found.
+    #
+    # Looks in
+    #
+    #   1. `public/` (precompiled; production)
+    #   2. the asset pipeline load paths (development; Propshaft or Sprockets)
+    #
+    # in that order. The pipeline lookup goes through `respond_to?` so that
+    # neither gem becomes a dependency (best effort).
+    def sghtmltopdf_asset_path(source)
+      path = source.to_s
+      # A source that is already a URL (or a `data:` URI) is not an asset of
+      # this application. Without this, `from_public_dir` would strip the host
+      # off `https://example.com/logo.png` and hand back `public/logo.png`.
+      return nil if path.match?(%r{\A(?:[a-z][a-z0-9+.\-]*:|//)}i)
+      return path if path.start_with?("/") && File.file?(path)
+
+      from_public_dir(path) || from_asset_pipeline(path)
+    end
+
+    # Expands the CSS itself into a `<style>`. Takes several sources; any that
+    # cannot be found are skipped silently (rendering still goes ahead).
+    #
+    # The file is not copied verbatim: its `url()`s are pointed at files the
+    # engine can read and its `@import`s are spliced in, see
+    # [#inline_stylesheet].
+    def sghtmltopdf_stylesheet_link_tag(*sources)
+      css = sources.flatten.filter_map do |source|
+        path = sghtmltopdf_asset_path(with_extension(source, ".css"))
+        inline_stylesheet(path) if path
+      end
+      return "".html_safe if css.empty?
+
+      content_tag(:style, css.join("\n").html_safe, type: "text/css")
+    end
+
+    # An `<img>` whose `src` the engine can read.
+    #
+    # The file is referenced by path, which keeps the HTML small: relative to
+    # `base_url` when it sits under it (the precompiled case), and the absolute
+    # filesystem path otherwise (the development case, where the file is still
+    # in the pipeline's load path). The engine reads an absolute `src` as a
+    # filesystem path once it fails to resolve under `base_url` (#44), so both
+    # forms reach the same file.
+    #
+    # A path only works if the engine is allowed to read there, so it is used
+    # only when `allow_path` (or `base_url`, with none set) covers the file.
+    # Everything else falls back to a `data:` URI, which depends on no
+    # configuration at all and therefore cannot fail: without that fallback a
+    # blocked path would just disappear from the PDF, since a failed asset fetch
+    # is ignored by default.
+    #
+    # `inline: true` forces embedding.
+    def sghtmltopdf_image_tag(source, options = {})
+      options = options.symbolize_keys
+      inline = options.delete(:inline)
+      path = sghtmltopdf_asset_path(source)
+      # Not an asset of this application (a remote URL, say): leave it to Rails.
+      return image_tag(source, options) if path.nil?
+
+      if !inline && (src = engine_readable_src(path))
+        # `image_tag` would rewrite the source (prefixing `/images/`, the asset
+        # host, and so on), so the tag is built directly. That skips the one
+        # option `image_tag` does more than copy, so `size:` is expanded here.
+        return tag.img(**expand_size(options).merge(src: src))
+      end
+      # A `data:` URI matches `AssetUrlHelper::URI_REGEXP`, so `image_tag`
+      # passes it through untouched and its own options keep working.
+      image_tag(data_uri(path), options)
+    end
+
+    private
+
+    # `path` read as CSS, with every `url()` pointed at a file the engine can
+    # read and every `@import` spliced in.
+    #
+    # Both have to happen here because the engine keeps one base for the whole
+    # document: every CSS source is concatenated before it is parsed, so a
+    # `url()` is resolved against the HTML's `base_url` whatever stylesheet it
+    # came from. Only this side knows where each file sits on disk, so each
+    # one's references are resolved against its own directory before its text
+    # is spliced into the next.
+    #
+    # What has to be undone is mostly the asset pipeline's own work: it
+    # rewrites every `url()` through `asset_path` while precompiling, which
+    # yields a digested `/assets/…` path, or an absolute URL once `asset_host`
+    # is set. Rendering never goes through the HTTP server, so neither can be
+    # fetched.
+    #
+    # `chain` holds the files already being expanded, innermost last.
+    def inline_stylesheet(path, chain = [])
+      css = File.read(path)
+      dir = File.dirname(path)
+      chain += [real_path(path)].compact
+      comments = comment_ranges(css)
+      out = +""
+      cursor = 0
+      while (import = IMPORT_STATEMENT.match(css, cursor))
+        commented = comments.any? { |range| range.cover?(import.begin(0)) }
+        expanded = imported_stylesheet(import[:href], dir, chain) unless commented
+        out << rewrite_css_urls(css[cursor...import.begin(0)].to_s, dir)
+        cursor = import.end(0)
+        out << (expanded || import[0])
+      end
+      out << rewrite_css_urls(css[cursor..].to_s, dir)
+    end
+
+    # The expanded content of an `@import` target, or `nil` to leave the
+    # statement as it is, which hands it to the engine untouched. That happens
+    # when it names no asset of this application, when the nesting is too deep,
+    # and when it points back at a file already being expanded.
+    #
+    # Media conditions on the statement are dropped. The engine replaces the
+    # whole statement with the imported text too, so nothing changes by doing
+    # it here.
+    def imported_stylesheet(href, dir, chain)
+      return nil if chain.length >= MAX_IMPORT_DEPTH
+
+      target = css_url_target(unquote(href), dir)
+      return nil if target.nil?
+
+      real = real_path(target)
+      return nil if real.nil? || chain.include?(real)
+
+      inline_stylesheet(target, chain)
+    end
+
+    # Byte ranges of the `/* … */` comments in `css`. A commented-out `@import`
+    # must not be spliced in.
+    def comment_ranges(css)
+      css.enum_for(:scan, CSS_COMMENT).map { Regexp.last_match.begin(0)...Regexp.last_match.end(0) }
+    end
+
+    # Every `url()` in `css` pointed at something the engine can read: a path
+    # when it may read the file there, a `data:` URI when it may not.
+    #
+    # A reference that names no file of this application is left alone, which
+    # covers `data:` URIs, bare fragments, and genuinely remote resources such
+    # as a font served by a CDN.
+    def rewrite_css_urls(css, dir)
+      css.gsub(CSS_URL) do
+        match = Regexp.last_match
+        target = css_url_target(unquote(match[:href]), dir)
+        target ? css_url(engine_readable_src(target) || data_uri(target)) : match[0]
+      end
+    end
+
+    # The local file a CSS reference names, or `nil` when it names none.
+    def css_url_target(ref, dir)
+      path = ref.split(/[?#]/, 2).first.to_s
+      return nil if path.empty? || path.match?(/\Adata:/i)
+
+      if path.match?(%r{\A(?:[a-z][a-z0-9+.\-]*:|//)}i)
+        # Only an http(s) or protocol-relative URL can be one of ours. The host
+        # is not compared against `asset_host`: it may be a callable or carry a
+        # `%d` wildcard, so there is no general way to recognise it. Finding the
+        # path on disk is the test instead, and what that finds is the very file
+        # the reference names.
+        return nil unless path.match?(%r{\A(?:https?:)?//}i)
+
+        path = path.sub(%r{\A(?:https?:)?//[^/]*}i, "")
+        return nil if path.empty?
+      end
+
+      path.start_with?("/") ? from_site_root(path) : from_stylesheet_dir(path, dir)
+    end
+
+    # A site-root-relative reference (`/assets/pdf-<digest>.css`) mapped onto a
+    # file. `relative_url_root` comes off first: the pipeline writes it in front
+    # of every URL, but it is a mount point, not a directory under `public/`.
+    def from_site_root(path)
+      root = ::Rails.application.config.try(:relative_url_root).to_s
+      path = path.delete_prefix(root) unless root.empty?
+      candidate = File.join(::Rails.public_path.to_s, path)
+      return candidate if File.file?(candidate)
+
+      # Nothing is precompiled in development, so the load path is asked as
+      # well. The mount point is not part of a logical path either.
+      logical = path.delete_prefix("/")
+      prefix = ::Rails.application.config.try(:assets)&.prefix.to_s.delete_prefix("/")
+      from_asset_pipeline(logical) ||
+        (prefix.empty? ? nil : from_asset_pipeline(logical.delete_prefix("#{prefix}/")))
+    end
+
+    # A reference relative to the stylesheet that wrote it, which is what CSS
+    # says it means and what the pipeline assumed while compiling the file.
+    #
+    # The load path is tried too. An uncompiled stylesheet sitting at the root
+    # of its own load path names assets by logical path, which is spelled the
+    # same way but is looked up across every root.
+    def from_stylesheet_dir(path, dir)
+      candidate = File.expand_path(path, dir)
+      return candidate if File.file?(candidate)
+
+      from_asset_pipeline(path.delete_prefix("./"))
+    end
+
+    # A `url()` whose argument is always quoted, so that a path holding a space
+    # or a parenthesis survives.
+    def css_url(value)
+      %(url("#{value.gsub(/["\\]/) { |char| "\\#{char}" }}"))
+    end
+
+    def unquote(value)
+      value = value.to_s.strip
+      quoted = value.match(/\A(["'])(.*)\1\z/m)
+      quoted ? quoted[2] : value
+    end
+
+    # Matches the engine's own cap (`core/src/style/import.rs`). Past it the
+    # statement is left in place and the engine decides what to do with it.
+    MAX_IMPORT_DEPTH = 16
+    private_constant :MAX_IMPORT_DEPTH
+
+    # `@import` up to its terminating `;`, in both the `url()` and the bare
+    # string form. Media conditions are matched so they are consumed, not kept.
+    IMPORT_STATEMENT = /
+      @import \s+
+      (?: url\( \s* (?<href> "[^"]*" | '[^']*' | [^)"'\s]* ) \s* \)
+        | (?<href> "[^"]*" | '[^']*' ) )
+      [^;]* ;
+    /xi
+    private_constant :IMPORT_STATEMENT
+
+    # A `url()` token. The lookbehind keeps identifiers ending in "url" out.
+    CSS_URL = /(?<![\w-])url\( \s* (?<href> "[^"]*" | '[^']*' | [^)"'\s]* ) \s* \)/xi
+    private_constant :CSS_URL
+
+    CSS_COMMENT = %r{/\*.*?\*/}m
+    private_constant :CSS_COMMENT
+
+    # Takes the path part of the URL `asset_path` returns (which may carry an
+    # asset host) and maps it onto a real file under `public/`.
+    def from_public_dir(source)
+      relative = asset_url_for(source).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
+
+    # `asset_path` for `source`, falling back to `source` itself.
+    #
+    # Both pipelines raise rather than return a path for an asset outside their
+    # load path (`Propshaft::MissingAssetError`,
+    # `Sprockets::Rails::Helper::AssetNotFound`). A file that lives only in
+    # `public/` is exactly that, so the raw source is tried against `public/`.
+    def asset_url_for(source)
+      return source unless respond_to?(:asset_path)
+
+      asset_path(source)
+    rescue StandardError
+      source
+    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
+
+    # `data:<type>;base64,<data>` for a local file. `pack("m0")` is strict
+    # base64 (no line breaks) and needs no require, unlike `Base64`, which is no
+    # longer a default gem on Ruby 3.4.
+    def data_uri(path)
+      base64 = [File.binread(path)].pack("m0")
+      "data:#{mime_type_of(path)};base64,#{base64}"
+    end
+
+    # The `src` to reference `file` by, or `nil` when the engine would not be
+    # allowed to read it there.
+    def engine_readable_src(file)
+      return nil unless engine_can_read?(file)
+
+      relative_to_base_url(file) || real_path(file)
+    end
+
+    # Whether the engine's rules for local files let it read `file`.
+    #
+    # `allow_path` decides on its own once it is set: the engine stops treating
+    # `base_url` as the boundary and consults the allowed directories only.
+    # A run that has no local access at all, or one delegated to a server that
+    # may not even share this filesystem, can read nothing here.
+    def engine_can_read?(file)
+      config = Sghtmltopdf.config
+      return false if config[:disable_local_file_access] || config[:server_url]
+
+      file = real_path(file)
+      return false if file.nil?
+
+      dirs = Array(config[:allow_path]).filter_map { |dir| real_path(dir) }
+      dirs = [real_path(config[:base_url])].compact if dirs.empty?
+      dirs.any? { |dir| file.start_with?(dir + File::SEPARATOR) }
+    end
+
+    # The path of `file` relative to the configured `base_url`, or `nil` when
+    # `base_url` is not a directory holding it (it may be an http(s) URL, or the
+    # file may live outside it, as an asset pipeline one in development does).
+    def relative_to_base_url(file)
+      base = real_path(Sghtmltopdf.config[:base_url])
+      full = real_path(file)
+      return nil if base.nil? || full.nil?
+
+      prefix = base + File::SEPARATOR
+      full.start_with?(prefix) ? full.delete_prefix(prefix) : nil
+    end
+
+    # `path` with symlinks resolved, or `nil` when it is not a local path at
+    # all. The engine canonicalizes both sides before comparing them, so a
+    # symlink pointing out of an allowed directory does not count as inside it.
+    def real_path(path)
+      path = path.to_s
+      return nil if path.empty? || path.match?(%r{\Ahttps?://}i)
+
+      File.realpath(path)
+    rescue SystemCallError
+      nil
+    end
+
+    # `image_tag`'s `size:` shorthand: "40x30", or "40" for a square. The tag is
+    # built without `image_tag` here, so the expansion has to happen here too.
+    def expand_size(options)
+      return options unless options.key?(:size)
+
+      if options[:height] || options[:width]
+        raise ArgumentError, "Cannot pass a :size option with a :height or :width option"
+      end
+
+      size = options[:size].to_s
+      options = options.except(:size)
+      case size
+      when /\A(\d+(?:\.\d+)?)x(\d+(?:\.\d+)?)\z/ then options.merge(width: $1, height: $2)
+      when /\A\d+(?:\.\d+)?\z/ then options.merge(width: size, height: size)
+      else options
+      end
+    end
+
+    # Media type from the file extension. The engine detects the format from the
+    # bytes, so this only has to be honest, not exhaustive.
+    def mime_type_of(path)
+      MIME_TYPES.fetch(File.extname(path).downcase.delete_prefix("."), "application/octet-stream")
+    end
+
+    MIME_TYPES = {
+      "png" => "image/png",
+      "jpg" => "image/jpeg",
+      "jpeg" => "image/jpeg",
+      "gif" => "image/gif",
+      "webp" => "image/webp",
+      "avif" => "image/avif",
+      "bmp" => "image/bmp",
+      "ico" => "image/vnd.microsoft.icon",
+      "tif" => "image/tiff",
+      "tiff" => "image/tiff",
+      "svg" => "image/svg+xml",
+      # Reached through a stylesheet's `url()`, not through `image_tag`.
+      "otf" => "font/otf",
+      "ttf" => "font/ttf",
+      "ttc" => "font/collection",
+      "woff" => "font/woff",
+      "woff2" => "font/woff2",
+      "eot" => "application/vnd.ms-fontobject",
+      "css" => "text/css"
+    }.freeze
+    private_constant :MIME_TYPES
+
+    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,123 @@
+# 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)
+      options = Options.canonicalize(options)
+      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)
+      options = Options.canonicalize(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.5.0
+platform: x86_64-darwin
+authors:
+- yo_waka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-09-20 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Ruby binding for sghtmltopdf, a successor to wkhtmltopdf: an HTML-to-PDF
+  rendering engine written in Rust that needs no browser process. The engine
+  runs in-process through a native extension and releases the GVL while
+  rendering. On Rails it registers a wicked_pdf compatible renderer, so
+  `render pdf: "invoice"` works with the keys you already use.
+email:
+- y.wakahara@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/sghtmltopdf.rb
+- lib/sghtmltopdf/3.2/sghtmltopdf.bundle
+- lib/sghtmltopdf/3.3/sghtmltopdf.bundle
+- lib/sghtmltopdf/3.4/sghtmltopdf.bundle
+- lib/sghtmltopdf/4.0/sghtmltopdf.bundle
+- 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.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: HTML to PDF renderer that does not depend on Chromium, WebKit, or Gecko
+test_files: []