sghtmltopdf 0.1.0

data/ext/sghtmltopdf/src/gvl.rs

@@ -0,0 +1,114 @@
+//! GVL(Global VM Lock)の解放。
+//!
+//! レンダリングの間はGVLを解放し、Pumaの他スレッドを止めないようにする。
+
+use std::ffi::c_void;
+use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
+
+/// GVLを解放して`func`を実行する。
+///
+/// # なぜ`Send`境界が要るか
+///
+/// magnusは「GVLを解放するAPIは存在しない」前提でGVL状態をスレッド
+/// ローカルにキャッシュしており(`magnus::api`の *assumed not to change
+/// because there's currently no api to unlock*)、ここで解放しても
+/// `Ruby::get()`は`Ok`を返してしまう。返ったハンドルでRubyに触ればUBになる。
+///
+/// `Send`境界を課すと、magnusの値(`NonNull<RBasic>`)も`Ruby`ハンドル
+/// (`*mut ()`)も`!Send`なのでキャプチャがコンパイルエラーになる。
+/// クロージャの中で改めて`Ruby::get()`を呼ぶことまでは型では防げないが、
+/// 解放区間で呼ぶのは`sghtmltopdf_core`の関数だけであり、コアはRubyを
+/// 一切知らないため到達しない。
+///
+/// # 割り込み
+///
+/// UBF(unblock function)は`None`＝割り込み不可。`Kernel#trap`やCtrl-Cでの
+/// 中断は初期スコープ外とする。
+#[allow(dead_code)] // 将来のGVL解放実装で使う
+pub fn without_gvl<F, R>(func: F) -> R
+where
+    F: FnOnce() -> R + Send,
+    R: Send,
+{
+    struct State<F, R> {
+        func: Option<F>,
+        result: Option<std::thread::Result<R>>,
+    }
+
+    unsafe extern "C" fn call<F, R>(arg: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> R + Send,
+        R: Send,
+    {
+        let state = unsafe { &mut *(arg as *mut State<F, R>) };
+        let func = state.func.take().expect("コールバックが2度呼ばれました");
+        // パニックがFFI境界を越えるとプロセスがabortするため、ここで捕まえて
+        // GVLを取り戻してからRust側でresumeする。
+        state.result = Some(catch_unwind(AssertUnwindSafe(func)));
+        std::ptr::null_mut()
+    }
+
+    let mut state = State::<F, R> {
+        func: Some(func),
+        result: None,
+    };
+    unsafe {
+        rb_sys::rb_thread_call_without_gvl(
+            Some(call::<F, R>),
+            &mut state as *mut _ as *mut c_void,
+            None,
+            std::ptr::null_mut(),
+        );
+    }
+    match state.result.expect("コールバックが実行されませんでした") {
+        Ok(value) => value,
+        Err(panic) => resume_unwind(panic),
+    }
+}
+
+/// GVLを取り戻して`func`を実行する。[`without_gvl`]の内側からだけ呼ぶ。
+///
+/// `without_gvl`と違い`Send`境界は課さない。ここはGVLを保持している＝Rubyに
+/// 触ってよい区間だから。
+///
+/// # 呼び出し側が守ること(libruby側の制約)
+///
+/// * `func`からRubyのオブジェクトを返さない。返すとGVLを再び手放した
+///   あとGCのスコープから外れ、マークされない。値を持ち帰るときは
+///   `rb_gc_register_address`で登録したスロットへ入れること
+///   (`callback_sink::ValueSlot`)
+/// * `func`から例外を投げさせない。longjmpがこの関数を飛び越えると
+///   未定義動作になる。Rubyの呼び出しは必ず`rb_protect`相当で包む
+///   (magnusの`Proc::call`は内部で`protect`しているのでそのまま使える)
+pub fn with_gvl<F, R>(func: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    struct State<F, R> {
+        func: Option<F>,
+        result: Option<std::thread::Result<R>>,
+    }
+
+    unsafe extern "C" fn call<F, R>(arg: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> R,
+    {
+        let state = unsafe { &mut *(arg as *mut State<F, R>) };
+        let func = state.func.take().expect("コールバックが2度呼ばれました");
+        // パニックがlibrubyのフレームを越えるとプロセスがabortする。
+        state.result = Some(catch_unwind(AssertUnwindSafe(func)));
+        std::ptr::null_mut()
+    }
+
+    let mut state = State::<F, R> {
+        func: Some(func),
+        result: None,
+    };
+    unsafe {
+        rb_sys::rb_thread_call_with_gvl(Some(call::<F, R>), &mut state as *mut _ as *mut c_void);
+    }
+    match state.result.expect("コールバックが実行されませんでした") {
+        Ok(value) => value,
+        Err(panic) => resume_unwind(panic),
+    }
+}

data/ext/sghtmltopdf/src/lib.rs

@@ -0,0 +1,167 @@
+//! Ruby拡張のエントリポイント。
+//!
+//! この層は薄く保つ。オプションの引数列(argv)への組み立てはRuby側が
+//! 行い、ここは受け取ったargvをCLI・HTTPサーバと同じパーサへ通して
+//! レンダリングするだけ。
+
+mod callback_sink;
+mod errors;
+mod gvl;
+
+use std::io::Cursor;
+use std::path::PathBuf;
+
+use magnus::rb_sys::AsRawValue;
+use magnus::{block::Proc, function, prelude::*, Error, RString, Ruby};
+use sghtmltopdf_core::cli::{self, convert};
+use sghtmltopdf_core::sink::{FileSink, MemorySink};
+
+use callback_sink::{pump_to_block, BlockSlot, PendingUnwind, ValueSlot};
+
+/// HTMLを変換してPDFのバイト列を返す。
+fn render(html: RString, argv: Vec<String>) -> Result<RString, Error> {
+    let ruby = Ruby::get().expect("GVLを保持したまま呼ばれるはず");
+    // GVLを解放する前にRust側へコピーする。解放中はRubyのオブジェクトに
+    // 触れないため、`RString`のままでは持ち込めない。
+    let html = unsafe { html.as_slice() }.to_vec();
+    errors::catch_panic(&ruby, move || render_inner(html, argv))
+}
+
+fn render_inner(html: Vec<u8>, argv: Vec<String>) -> Result<RString, Error> {
+    let ruby = Ruby::get().expect("GVLを保持したまま呼ばれるはず");
+    let (args, fonts) = cli::parse_convert_argv(&argv).map_err(|e| errors::to_ruby(&ruby, e))?;
+
+    // GVLを解放したうえで、さらにレンダリング専用のスタックを確保した
+    // スレッドへ移す。Rubyのスレッドのマシンスタックは既定1MiBしかなく、
+    // レイアウト・描画の再帰に耐えられないため(`callback_sink`のモジュール
+    // doc参照)。この経路はRubyへコールバックしないので、そのまま移せる。
+    let pdf = gvl::without_gvl(move || {
+        cli::with_render_stack(move || {
+            convert::render_to_memory(&args, &fonts, Cursor::new(html), MemorySink::new())
+        })
+    })
+    .map_err(|e| errors::to_ruby(&ruby, e))?;
+
+    Ok(ruby.str_from_slice(&pdf))
+}
+
+/// HTMLを変換して`path`へ書き出す。
+///
+/// 出力先は[`FileSink`]が決めるので、argvの`--output`は使われない
+/// (一時ファイルへ書いて成功時だけrenameするため、途中で失敗しても
+/// 壊れたPDFが残らない)。
+fn render_to_file(html: RString, argv: Vec<String>, path: String) -> Result<(), Error> {
+    let ruby = Ruby::get().expect("GVLを保持したまま呼ばれるはず");
+    let html = unsafe { html.as_slice() }.to_vec();
+    errors::catch_panic(&ruby, move || render_to_file_inner(html, argv, path))
+}
+
+fn render_to_file_inner(html: Vec<u8>, argv: Vec<String>, path: String) -> Result<(), Error> {
+    let ruby = Ruby::get().expect("GVLを保持したまま呼ばれるはず");
+    let (args, fonts) = cli::parse_convert_argv(&argv).map_err(|e| errors::to_ruby(&ruby, e))?;
+
+    let path = PathBuf::from(path);
+    let sink = FileSink::create(&path).map_err(|e| {
+        errors::to_ruby(
+            &ruby,
+            cli::CliError::Input(format!("{}の作成に失敗しました: {e}", path.display())),
+        )
+    })?;
+
+    gvl::without_gvl(move || {
+        cli::with_render_stack(move || convert::render(&args, &fonts, Cursor::new(html), sink))
+    })
+    .map_err(|e| errors::to_ruby(&ruby, e))?;
+    Ok(())
+}
+
+/// HTMLを変換し、確定したPDFのバイト列を`chunk_size`ごとに`block`へ渡す。
+///
+/// レンダリングの間はGVLを解放し、ブロックを呼ぶ瞬間だけ取り戻す。ブロックが
+/// 例外を投げた場合は、その例外をそのまま呼び出し元へ伝える(エンジン側は
+/// 通常のエラーパスで巻き戻る)。
+fn render_each(
+    html: RString,
+    argv: Vec<String>,
+    block: Proc,
+    chunk_size: usize,
+) -> Result<(), Error> {
+    let ruby = Ruby::get().expect("GVLを保持したまま呼ばれるはず");
+    let html = unsafe { html.as_slice() }.to_vec();
+    errors::catch_panic(&ruby, move || {
+        render_each_inner(html, argv, block, chunk_size)
+    })
+}
+
+fn render_each_inner(
+    html: Vec<u8>,
+    argv: Vec<String>,
+    block: Proc,
+    chunk_size: usize,
+) -> Result<(), Error> {
+    let ruby = Ruby::get().expect("GVLを保持したまま呼ばれるはず");
+    let (args, fonts) = cli::parse_convert_argv(&argv).map_err(|e| errors::to_ruby(&ruby, e))?;
+
+    // ブロックはGVL解放区間をまたいで生きる必要があるため、GCへ登録する
+    // (解放後にスタックへ積んだ値は保守的GCの走査対象外)。
+    let block = ValueSlot::new(block.as_raw());
+    let mut pending = PendingUnwind::default();
+
+    let result = {
+        let slot = BlockSlot::new(&block);
+        let pending = &mut pending;
+        gvl::without_gvl(move || {
+            // レンダリングは専用スタックのスレッドで走り、確定したチャンクだけが
+            // ここへ戻ってくる。ブロックの呼び出し(=GVLの再取得)は、GVLを
+            // 手放したこのスレッドで行う必要があるため`pump_to_block`に任せる。
+            pump_to_block(slot, pending, chunk_size, move |sink| {
+                convert::render(&args, &fonts, Cursor::new(html), sink)
+            })
+        })
+    };
+    drop(block);
+
+    // ブロック由来の中断は、エンジンが返すエラーより優先して伝える
+    // (`Sink::Error`が`io::Error`固定のため、理由はこちらに載っている)。
+    // `break`等の脱出は`into_error`の中で`rb_jump_tag`し戻らないので、
+    // Rust側の値はここで落としきってから呼ぶ。
+    if pending.is_pending() {
+        drop(result);
+        return Err(pending
+            .into_error()
+            .expect("is_pendingがtrueなら中断が入っている"));
+    }
+    result.map_err(|e| errors::to_ruby(&ruby, e))
+}
+
+/// coreへリンクできていることの確認用(疎通確認)。
+fn core_version() -> String {
+    env!("CARGO_PKG_VERSION").to_string()
+}
+
+/// coreのシンボルを実際に1つ呼んでリンクを確かめる。
+fn default_page_size() -> String {
+    let settings = sghtmltopdf_core::layout::PageSettings::default();
+    format!("{}x{}", settings.size.width, settings.size.height)
+}
+
+/// GVLを解放して実行できることの確認用。解放中も他のRubyスレッドが
+/// 進めることをRuby側のテストで検証する。
+fn sleep_without_gvl(ms: u64) {
+    gvl::without_gvl(|| std::thread::sleep(std::time::Duration::from_millis(ms)));
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Sghtmltopdf")?;
+    errors::define(ruby, module)?;
+
+    let native = module.define_module("Native")?;
+    native.define_singleton_method("render", function!(render, 2))?;
+    native.define_singleton_method("render_to_file", function!(render_to_file, 3))?;
+    native.define_singleton_method("render_each", function!(render_each, 4))?;
+    native.define_singleton_method("core_version", function!(core_version, 0))?;
+    native.define_singleton_method("default_page_size", function!(default_page_size, 0))?;
+    native.define_singleton_method("sleep_without_gvl", function!(sleep_without_gvl, 1))?;
+    Ok(())
+}

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