fulgur 0.8.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a90fd2fe60c5be06f30e3929dba2cafe3a73828fb7605cbb309884e529c6cbfd
-  data.tar.gz: 10a64dcecaeaaf75f16a78dcccd61081c7765b6b522725de0c069744344404c5
+  metadata.gz: 7e8f8d469b4c66f85a50347a85a9ef5f740e911e7af64bbc02755ae92dae2c13
+  data.tar.gz: 5672b32788488af9938d70e9db3c0d2f1a3aad4804aefe663f6225eddcc20ea1
 SHA512:
-  metadata.gz: 233869bcf94e319d172bb4038f39965148f2ffc8c117de7e330474ef994cb54edb0aba023ba34eea181b4da6398ad18af3d296252e521e51d0c49b9274aea143
-  data.tar.gz: d8c4c96138be3d2a011ef3dc58956151e5faa1440aca525dec82b8083abfa7390f0a92cd1ae1d3ec07325238a0e786afe40d50975afedecbc367b24f1a8bf66e
+  metadata.gz: d2809932eceae4cb1c4a1f5aa09a81b9d351f714b597723e5addd7e2ddd1e19d298471344af8853bf616fc78eedf142fe54c8ea6f5497d97a9aa88362f8863e4
+  data.tar.gz: 7e9aa059550797e7295910e34cd025a1c0c92e2a1e374ff607b898e8052911308f2a5a45c98064fb7e01ba2dcc9ea5633e0bac5b09d29a82ba0aed78243d8ec8

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fulgur-ruby"
-version = "0.8.0"
+version = "0.12.0"
 # rb_sys cross-gem-action は `directory: crates/fulgur-ruby` のみをコンテナに
 # マウントするため、この Cargo.toml は workspace root 不在でも cargo metadata
 # を解決できる必要がある。したがって workspace 継承 (`.workspace = true`) は

data/ext/fulgur/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "fulgur"
-version = "0.8.0"
+version = "0.12.0"
 # crates/fulgur-ruby/Cargo.toml と同じ src を共有 (path = "../../src/lib.rs")。
 # workspace と同じ edition 2024 に揃える。
 edition = "2024"
@@ -22,7 +22,7 @@ ruby-api = ["dep:magnus", "dep:rb-sys"]
 # を参照する (release 時は release.yml → release: published → release-ruby.yml の順で
 # 発火するため、この時点で fulgur のバージョンは crates.io に存在する)。
 # release-prepare.yml が sed でこの行のバージョンを同期する。
-fulgur = "0.8.0"
+fulgur = "0.12.0"
 base64 = "0.22"
 magnus = { version = "0.7", optional = true }
 rb-sys = { version = "0.9", optional = true }

data/lib/fulgur/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fulgur
-  VERSION = "0.8.0"
+  VERSION = "0.12.0"
 end

data/src/asset_bundle.rs

@@ -66,8 +66,8 @@ impl RbAssetBundle {
     }
 }
 
-pub fn define(_ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
-    let class = fulgur.define_class("AssetBundle", magnus::class::object())?;
+pub fn define(ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
+    let class = fulgur.define_class("AssetBundle", ruby.class_object())?;
     class.define_singleton_method("new", function!(RbAssetBundle::new, 0))?;
     class.define_method("add_css", method!(RbAssetBundle::add_css, 1))?;
     class.define_method("add_css_file", method!(RbAssetBundle::add_css_file, 1))?;

data/src/engine.rs

@@ -36,8 +36,9 @@ impl RbEngineBuilder {
 
     fn take(&self) -> Result<EngineBuilder, Error> {
         self.inner.borrow_mut().take().ok_or_else(|| {
+            let ruby = Ruby::get().expect("ruby vm");
             Error::new(
-                magnus::exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 "EngineBuilder has already been built",
             )
         })
@@ -273,8 +274,8 @@ fn engine_builder() -> RbEngineBuilder {
     RbEngineBuilder::new()
 }
 
-pub fn define(_ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
-    let engine = fulgur.define_class("Engine", magnus::class::object())?;
+pub fn define(ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
+    let engine = fulgur.define_class("Engine", ruby.class_object())?;
     engine.define_singleton_method("new", function!(engine_new, -1))?;
     engine.define_singleton_method("builder", function!(engine_builder, 0))?;
     engine.define_method("render_html", method!(RbEngine::render_html, 1))?;
@@ -283,7 +284,7 @@ pub fn define(_ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
         method!(RbEngine::render_html_to_file, 2),
     )?;
 
-    let builder = fulgur.define_class("EngineBuilder", magnus::class::object())?;
+    let builder = fulgur.define_class("EngineBuilder", ruby.class_object())?;
     builder.define_method("page_size", method!(builder_page_size, 1))?;
     builder.define_method("margin", method!(builder_margin, 1))?;
     builder.define_method("assets", method!(builder_assets, 1))?;

data/src/error.rs

@@ -5,7 +5,7 @@
 //! `fulgur::Error` の variant に応じて適切な Ruby 例外に変換する。
 
 use fulgur::Error as FulgurError;
-use magnus::{Error, ExceptionClass, Module, RModule, Ruby, exception};
+use magnus::{Error, ExceptionClass, Module, RModule, Ruby};
 
 /// Ruby 側の `Fulgur::<name>` 例外クラスを lookup する。
 fn class(ruby: &Ruby, name: &str) -> Result<ExceptionClass, Error> {
@@ -28,7 +28,7 @@ pub fn map_fulgur_error(ruby: &Ruby, err: FulgurError) -> Error {
                     .class_object()
                     .const_get::<_, RModule>("Errno")
                     .and_then(|m| m.const_get::<_, ExceptionClass>("ENOENT"))
-                    .unwrap_or_else(|_| exception::runtime_error());
+                    .unwrap_or_else(|_| ruby.exception_runtime_error());
                 Error::new(errno, io_err.to_string())
             }
             _ => render_error(ruby, io_err.to_string()),
@@ -46,13 +46,13 @@ pub fn map_fulgur_error(ruby: &Ruby, err: FulgurError) -> Error {
 fn render_error(ruby: &Ruby, msg: String) -> Error {
     match class(ruby, "RenderError") {
         Ok(c) => Error::new(c, msg),
-        Err(_) => Error::new(exception::runtime_error(), msg),
+        Err(_) => Error::new(ruby.exception_runtime_error(), msg),
     }
 }
 
 fn asset_error(ruby: &Ruby, msg: String) -> Error {
     match class(ruby, "AssetError") {
         Ok(c) => Error::new(c, msg),
-        Err(_) => Error::new(exception::runtime_error(), msg),
+        Err(_) => Error::new(ruby.exception_runtime_error(), msg),
     }
 }

data/src/lib.rs

@@ -6,7 +6,7 @@
 
 #![cfg(feature = "ruby-api")]
 
-use magnus::{Error, define_module};
+use magnus::Error;
 
 mod asset_bundle;
 mod engine;
@@ -30,7 +30,7 @@ mod assertions {
 
 #[magnus::init]
 fn init(ruby: &magnus::Ruby) -> Result<(), Error> {
-    let fulgur = define_module("Fulgur")?;
+    let fulgur = ruby.define_module("Fulgur")?;
     page_size::define(ruby, &fulgur)?;
     margin::define(ruby, &fulgur)?;
     asset_bundle::define(ruby, &fulgur)?;

data/src/margin.rs

@@ -61,8 +61,8 @@ impl RbMargin {
     }
 }
 
-pub fn define(_ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
-    let class = fulgur.define_class("Margin", magnus::class::object())?;
+pub fn define(ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
+    let class = fulgur.define_class("Margin", ruby.class_object())?;
     class.define_singleton_method("__build__", function!(RbMargin::from_trbl, 4))?;
     class.define_singleton_method("uniform", function!(RbMargin::uniform, 1))?;
     class.define_singleton_method("symmetric", function!(RbMargin::symmetric, 2))?;

data/src/page_size.rs

@@ -59,8 +59,9 @@ pub fn extract(value: Value) -> Result<PageSize, Error> {
     if let Ok(s) = <String>::try_convert(value) {
         return parse_name(&s);
     }
+    let ruby = Ruby::get().expect("ruby vm");
     Err(Error::new(
-        magnus::exception::arg_error(),
+        ruby.exception_arg_error(),
         "page_size must be Symbol, String, or Fulgur::PageSize",
     ))
 }
@@ -70,15 +71,18 @@ fn parse_name(name: &str) -> Result<PageSize, Error> {
         "A4" => Ok(PageSize::A4),
         "LETTER" => Ok(PageSize::LETTER),
         "A3" => Ok(PageSize::A3),
-        other => Err(Error::new(
-            magnus::exception::arg_error(),
-            format!("unknown page size: {other}"),
-        )),
+        other => {
+            let ruby = Ruby::get().expect("ruby vm");
+            Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("unknown page size: {other}"),
+            ))
+        }
     }
 }
 
-pub fn define(_ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
-    let class = fulgur.define_class("PageSize", magnus::class::object())?;
+pub fn define(ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
+    let class = fulgur.define_class("PageSize", ruby.class_object())?;
     class.define_singleton_method("custom", function!(RbPageSize::custom, 2))?;
     class.define_method("width", method!(RbPageSize::width, 0))?;
     class.define_method("height", method!(RbPageSize::height, 0))?;

data/src/pdf.rs

@@ -24,8 +24,9 @@ impl RbPdf {
     }
 
     fn to_s(&self) -> RString {
-        // `RString::from_slice` は ASCII-8BIT (binary) encoding の Ruby String を返す。
-        RString::from_slice(&self.bytes)
+        // `Ruby::str_from_slice` は ASCII-8BIT (binary) encoding の Ruby String を返す。
+        let ruby = Ruby::get().expect("ruby vm");
+        ruby.str_from_slice(&self.bytes)
     }
 
     fn to_base64(&self) -> String {
@@ -62,18 +63,19 @@ impl RbPdf {
     /// - `IO#write` が要求より少ないバイト数を返した場合 (socket / pipe / 独自 IO の短書き込み)
     ///   は残りを再送する。戻り値が 0 の場合は無限ループを防ぐため `RuntimeError` を返す。
     fn write_to_io(&self, io: Value) -> Result<(), Error> {
-        let responds: bool = io.funcall("respond_to?", (magnus::Symbol::new("binmode"),))?;
+        let ruby = Ruby::get().expect("ruby vm");
+        let responds: bool = io.funcall("respond_to?", (ruby.to_symbol("binmode"),))?;
         if responds {
             let _: Value = io.funcall("binmode", ())?;
         }
         for chunk in self.bytes.chunks(CHUNK_SIZE) {
             let mut offset = 0;
             while offset < chunk.len() {
-                let rb_bytes = RString::from_slice(&chunk[offset..]);
+                let rb_bytes = ruby.str_from_slice(&chunk[offset..]);
                 let written: usize = io.funcall("write", (rb_bytes,))?;
                 if written == 0 {
                     return Err(Error::new(
-                        magnus::exception::runtime_error(),
+                        ruby.exception_runtime_error(),
                         "IO#write returned 0 bytes; cannot make progress",
                     ));
                 }
@@ -87,7 +89,8 @@ impl RbPdf {
 /// Ruby 値をファイルパス文字列に変換する。`Pathname` 等 `to_path` に応答する
 /// オブジェクトを受け入れ、そうでなければ `to_str` で暗黙変換する。
 pub(crate) fn coerce_to_path(value: Value) -> Result<String, Error> {
-    let responds: bool = value.funcall("respond_to?", (magnus::Symbol::new("to_path"),))?;
+    let ruby = Ruby::get().expect("ruby vm");
+    let responds: bool = value.funcall("respond_to?", (ruby.to_symbol("to_path"),))?;
     let converted: Value = if responds {
         value.funcall("to_path", ())?
     } else {
@@ -95,14 +98,14 @@ pub(crate) fn coerce_to_path(value: Value) -> Result<String, Error> {
     };
     <String>::try_convert(converted).map_err(|_| {
         Error::new(
-            magnus::exception::type_error(),
+            ruby.exception_type_error(),
             "path must be a String or respond to to_path",
         )
     })
 }
 
-pub fn define(_ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
-    let class = fulgur.define_class("Pdf", magnus::class::object())?;
+pub fn define(ruby: &Ruby, fulgur: &RModule) -> Result<(), Error> {
+    let class = fulgur.define_class("Pdf", ruby.class_object())?;
     class.define_method("bytesize", method!(RbPdf::bytesize, 0))?;
     class.define_method("to_s", method!(RbPdf::to_s, 0))?;
     class.define_method("to_base64", method!(RbPdf::to_base64, 0))?;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fulgur
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Mitsuru Hayasaka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-25 00:00:00.000000000 Z
+date: 2026-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys