rmagick_tidy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f147dcd4088210662a53b4a66911e721b5b5a506ff4b1bead65db5a94ac873b
+  data.tar.gz: c80d6229d5ef1e1272097f3d30b939629c04ddb29bed8f185c2a01dc4f7f4d05
+SHA512:
+  metadata.gz: e60b3a6a5812a68936e71e73f073ce9f1d1f57032df67ff05c99c5279acba8fc7f935f8435c263388f95a31ac784ba09caa7e10d63954810f155ef3fadf5f592
+  data.tar.gz: 63f5780ab884f412049b3fc7290e3f0a050ce8859a66fd87952417156e978ec6f0623efbadb2b98d88711289158e03130efecce5adedea1aa92351bda61b3d73

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-05-21
+
+### Added
+- Initial release: `RmagickTidy.scope` block that tracks every `Magick::Image` / `Magick::ImageList` created inside it and calls `destroy!` on them when the block exits.
+- `LICENSE` file (MIT).
+- Gem metadata (`source_code_uri`, `changelog_uri`, `bug_tracker_uri`, `rubygems_mfa_required`).
+- RuboCop and SimpleCov for style and coverage; both run in CI.
+- Codecov integration: CI emits `coverage/lcov.info` (via `simplecov-lcov`) and uploads it through `codecov/codecov-action@v4`. README displays the live coverage badge.
+- RSpec coverage for nested `Hash`/`Array` return values, `ImageList` iteration, missing `destroyed?`, `nil` / empty returns, and `destroy!` exception paths.
+- README note about `Configuration` thread-safety expectations.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Junichiro Kasuya
+
+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.ja.md

@@ -0,0 +1,129 @@
+# rmagick_tidy
+
+[![CI](https://github.com/jksy/rmagick_tidy/actions/workflows/ci.yml/badge.svg)](https://github.com/jksy/rmagick_tidy/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/jksy/rmagick_tidy/branch/main/graph/badge.svg)](https://codecov.io/gh/jksy/rmagick_tidy)
+
+`rmagick_tidy` は RMagick (`Magick::Image`) のメモリ管理を**スコープベース**で自動化する Ruby gem です。
+
+RMagick が確保するメモリの実体は ImageMagick の C レイヤー側にあります。Ruby の GC は Ruby が確保したメモリしか把握しないため、ImageMagick 側の使用量を過小評価し、GC が適時に発火しません。Ruby ラッパが回収されるタイミングで C 側のメモリも最終的には解放されますが、それまではプロセスの RSS が膨らみ続けます。これを避けるため、`ensure + destroy!` を各所に手書きして即時解放しているプロジェクトが多いのが現状です。本 gem はその定型処理を 1 ブロックに集約します。
+
+English: [README.md](README.md)
+
+## インストール
+
+```ruby
+# Gemfile
+gem "rmagick_tidy"
+```
+
+```ruby
+require "rmagick_tidy"
+```
+
+`require` した時点で `Magick::Image` / `Magick::ImageList` のフックがインストールされます。
+
+## 基本的な使い方
+
+```ruby
+RmagickTidy.scope do
+  img = Magick::Image.read("input.jpg").first
+  resized = img.resize(800, 600)
+  resized.write("output.jpg")
+end
+# ブロックを抜けたタイミングで img, resized が destroy! 済み
+```
+
+### ブロックの戻り値は解放されない（keep）
+
+呼び出し元に画像を返したい場合は、その画像をブロックの戻り値にします。
+
+```ruby
+result = RmagickTidy.scope do
+  img = Magick::Image.read("input.jpg").first
+  img.resize(800, 600)   # ← この戻り値だけは keep
+end
+# result は生きている。元の img は destroy! 済み
+
+result.write("out.jpg")
+result.destroy!
+```
+
+戻り値は `Magick::Image` 単体だけでなく、`Array<Image>`、`Hash` の値、`Magick::ImageList` 内の要素も再帰的に keep されます。
+
+### ネスト
+
+```ruby
+RmagickTidy.scope do        # 外側
+  outer = Magick::Image.read("a.jpg").first
+  RmagickTidy.scope do      # 内側
+    inner = outer.resize(100, 100)
+    # inner はここで destroy!
+  end
+  # outer はまだ生きている
+end
+```
+
+### 例外時も解放される
+
+```ruby
+RmagickTidy.scope do
+  img = Magick::Image.read("x.jpg").first
+  raise "boom"
+end
+# img は destroy! されてから例外が再送出される
+```
+
+### bang メソッドは二重登録されない
+
+`resize!` などの bang メソッドは `self` を返すため、`equal?` で判定して再登録しません。
+
+## Rails で使う
+
+`require "rmagick_tidy"` を済ませると Railtie が `ActionController::Base` に `within_rmagick_tidy_scope` を mixin します。
+
+```ruby
+class ImagesController < ApplicationController
+  around_action :within_rmagick_tidy_scope
+
+  def show
+    img = Magick::Image.read(@source).first
+    @blob = img.resize(800, 600).to_blob { |info| info.format = "JPEG" }
+    send_data @blob, type: "image/jpeg"
+  end
+end
+```
+
+`to_blob` は `String` を返すのでスコープの解放対象になりません。Image オブジェクトのみがクリーンアップされます。
+
+## strict モード
+
+開発・テスト環境で「スコープ外で作られた Image」を検知したいときに使います。
+
+```ruby
+RmagickTidy.configure do |c|
+  c.strict_mode = :warn   # or :raise / :off (default)
+end
+```
+
+- `:off` — 何もしない（本番デフォルト）
+- `:warn` — `warn` で標準エラー出力に通知
+- `:raise` — `RmagickTidy::OutOfScopeError` を発生
+
+> **Configuration はスレッドセーフではありません。** `strict_mode`（および将来追加されるオプション）は **起動時に 1 回だけ**設定してください（例: Rails の initializer）。ワーカースレッドが `Magick::Image` を使い始めたあとに別スレッドから書き換える挙動は未定義です。
+
+## 仕組み
+
+- `Magick::Image` / `Magick::ImageList` に対し、`Module#prepend` で全ての public instance method（および `new`, `read`, `from_blob`, ...のクラスメソッド）をラップ
+- **戻り値の型をチェック**して `Magick::Image` であれば現在のスコープに登録（ホワイトリストを持たないので RMagick のバージョン差異を吸収）
+- 戻り値が `self` と `equal?` なら bang メソッドとみなして登録しない
+- スコープスタックは `Thread.current` 配下なのでマルチスレッド環境でも安全
+- 二重 `destroy!` は `destroyed?` 判定 + rescue で防止
+
+## 対応バージョン
+
+- Ruby 3.2 以上
+- RMagick 2.x 〜 6.x（戻り値チェック方式のため幅広く動作）
+
+## ライセンス
+
+MIT

data/README.md

@@ -0,0 +1,132 @@
+# rmagick_tidy
+
+[![CI](https://github.com/jksy/rmagick_tidy/actions/workflows/ci.yml/badge.svg)](https://github.com/jksy/rmagick_tidy/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/jksy/rmagick_tidy/branch/main/graph/badge.svg)](https://codecov.io/gh/jksy/rmagick_tidy)
+
+`rmagick_tidy` is a Ruby gem that automates **scope-based memory management** for RMagick (`Magick::Image`).
+
+The bulk of the memory an `Magick::Image` represents is allocated by ImageMagick in C, outside Ruby's heap. Ruby's GC only accounts for memory it allocated itself, so it underestimates the real footprint and fires far less often than the actual memory pressure warrants. The C-side memory is eventually freed when the Ruby wrapper is collected, but until then the process's RSS keeps climbing. To avoid that, many projects scatter `ensure` / `destroy!` pairs through their code to release the memory immediately. This gem replaces that boilerplate with a single block.
+
+日本語版: [README.ja.md](README.ja.md)
+
+## Installation
+
+```ruby
+# Gemfile
+gem "rmagick_tidy"
+```
+
+```ruby
+require "rmagick_tidy"
+```
+
+Hooks for `Magick::Image` and `Magick::ImageList` are installed when the gem is required.
+
+## Basic usage
+
+```ruby
+RmagickTidy.scope do
+  img = Magick::Image.read("input.jpg").first
+  resized = img.resize(800, 600)
+  resized.write("output.jpg")
+end
+# Both img and resized have been released by the time the block exits.
+```
+
+### The block return value is preserved (keep set)
+
+When you need to return an image to the caller, make it the block's return value.
+
+```ruby
+result = RmagickTidy.scope do
+  img = Magick::Image.read("input.jpg").first
+  img.resize(800, 600)   # returned from the block, so it is kept
+end
+# result is still alive; the original img has been released.
+
+result.write("out.jpg")
+result.destroy!
+```
+
+The keep set walks the return value recursively: a single `Magick::Image`, an `Array<Image>`, the values of a `Hash`, and the elements of a `Magick::ImageList` are all preserved.
+
+### Nesting
+
+```ruby
+RmagickTidy.scope do        # outer scope
+  outer = Magick::Image.read("a.jpg").first
+  RmagickTidy.scope do      # inner scope
+    inner = outer.resize(100, 100)
+    # inner is released here.
+  end
+  # outer is still alive.
+end
+```
+
+### Cleanup runs on exceptions too
+
+```ruby
+RmagickTidy.scope do
+  img = Magick::Image.read("x.jpg").first
+  raise "boom"
+end
+# img is released before the exception propagates.
+```
+
+### Bang methods are not registered twice
+
+Bang methods such as `resize!` return `self`. `rmagick_tidy` detects this with an `equal?` check and skips re-registration, so the same image is never released twice.
+
+## Rails integration
+
+After `require "rmagick_tidy"`, a Railtie mixes `within_rmagick_tidy_scope` into `ActionController::Base`.
+
+```ruby
+class ImagesController < ApplicationController
+  around_action :within_rmagick_tidy_scope
+
+  def show
+    img = Magick::Image.read(@source).first
+    @blob = img.resize(800, 600).to_blob { |info| info.format = "JPEG" }
+    send_data @blob, type: "image/jpeg"
+  end
+end
+```
+
+`to_blob` returns a `String`, so it is never treated as a cleanup target — only the image objects are released.
+
+## Strict mode
+
+Use strict mode in development or test environments to catch images created outside of a scope.
+
+```ruby
+RmagickTidy.configure do |c|
+  c.strict_mode = :warn   # or :raise / :off (default)
+end
+```
+
+- `:off` — do nothing (the production default)
+- `:warn` — print a warning to stderr
+- `:raise` — raise `RmagickTidy::OutOfScopeError`
+
+> **Configuration is not thread-safe.** Set `strict_mode` (and any future
+> options) **once at boot** — for example from a Rails initializer — before any
+> worker thread starts using `Magick::Image`. Reading and writing the value
+> from multiple threads concurrently is undefined.
+
+## How it works
+
+- `Magick::Image` and `Magick::ImageList` are hooked with `Module#prepend`, wrapping every public instance method as well as class methods such as `new`, `read`, and `from_blob`.
+- Each wrapped method **inspects its return value**: if it is a `Magick::Image`, the image is registered with the current scope. Because the gem keeps no method whitelist, it works across a wide range of RMagick versions.
+- If the return value is `equal?` to `self`, it is treated as a bang method and not registered.
+- The scope stack lives in `Thread.current`, so it is safe to use under multi-threaded servers such as Puma.
+- Calling `destroy!` twice is guarded against with a `destroyed?` check and a defensive `rescue`.
+
+## Compatibility
+
+- Ruby 3.2 or newer
+- RMagick 2.x through 6.x (the return-value approach keeps the gem broadly compatible)
+
+## License
+
+MIT

data/lib/rmagick_tidy/configuration.rb

@@ -0,0 +1,12 @@
+module RmagickTidy
+  class Configuration
+    # :off (default), :warn, :raise
+    attr_accessor :strict_mode
+
+    def initialize
+      @strict_mode = :off
+    end
+  end
+
+  class OutOfScopeError < StandardError; end
+end

data/lib/rmagick_tidy/hook.rb

@@ -0,0 +1,68 @@
+module RmagickTidy
+  module Hook
+    # Methods we never want to wrap. Most of them either return self, return
+    # primitives, or are introspection / lifecycle helpers where wrapping would
+    # be wasteful or risk recursion.
+    SKIP_INSTANCE_METHODS = %i[
+      destroy! destroyed? inspect to_s == eql? hash freeze frozen?
+      tainted? untrusted? object_id class itself
+    ].freeze
+
+    # Class-level methods on Magick::Image that produce new images.
+    CLASS_METHODS = %i[new read ping from_blob read_inline capture constitute combine].freeze
+
+    module_function
+
+    def install!
+      return if @installed
+      return unless defined?(::Magick::Image)
+
+      install_instance_hook(::Magick::Image)
+      install_class_hook(::Magick::Image)
+
+      if defined?(::Magick::ImageList)
+        install_instance_hook(::Magick::ImageList)
+        install_class_hook(::Magick::ImageList)
+      end
+
+      @installed = true
+    end
+
+    def install_instance_hook(klass)
+      mod = Module.new do
+        def self.inspect = "#<RmagickTidy::InstanceHook>"
+      end
+      method_names = klass.public_instance_methods(false) - SKIP_INSTANCE_METHODS
+      method_names.each do |name|
+        next if name.to_s.end_with?("=")
+
+        define_wrapper(mod, name)
+      end
+      klass.prepend(mod)
+    end
+
+    def install_class_hook(klass)
+      mod = Module.new do
+        def self.inspect = "#<RmagickTidy::ClassHook>"
+      end
+      CLASS_METHODS.each do |name|
+        next unless klass.respond_to?(name)
+
+        define_wrapper(mod, name)
+      end
+      klass.singleton_class.prepend(mod)
+    end
+
+    def define_wrapper(mod, name)
+      mod.send(:define_method, name) do |*args, **kwargs, &block|
+        result = if kwargs.empty?
+                   super(*args, &block)
+                 else
+                   super(*args, **kwargs, &block)
+                 end
+        ::RmagickTidy::Tracker.track(result, self)
+        result
+      end
+    end
+  end
+end

data/lib/rmagick_tidy/railtie.rb

@@ -0,0 +1,18 @@
+module RmagickTidy
+  module ControllerHelper
+    # Use as `around_action :within_rmagick_tidy_scope`.
+    def within_rmagick_tidy_scope(&)
+      RmagickTidy.scope(&)
+    end
+  end
+
+  if defined?(::Rails::Railtie)
+    class Railtie < ::Rails::Railtie
+      initializer "rmagick_tidy.controller" do
+        ActiveSupport.on_load(:action_controller) do
+          include ::RmagickTidy::ControllerHelper
+        end
+      end
+    end
+  end
+end

data/lib/rmagick_tidy/registry.rb

@@ -0,0 +1,73 @@
+module RmagickTidy
+  class Scope
+    attr_reader :images, :keeps
+
+    def initialize
+      @images = []
+      @keeps = {}.compare_by_identity
+    end
+
+    def register(image)
+      @images << image
+    end
+
+    def keep(image)
+      @keeps[image] = true
+    end
+
+    def keep?(image)
+      @keeps.key?(image)
+    end
+  end
+
+  module Registry
+    STACK_KEY = :rmagick_tidy_stack
+
+    module_function
+
+    def stack
+      Thread.current[STACK_KEY] ||= []
+    end
+
+    def current
+      stack.last
+    end
+
+    def in_scope?
+      !stack.empty?
+    end
+
+    def push
+      stack.push(Scope.new)
+    end
+
+    def pop_and_destroy
+      scope = stack.pop
+      return unless scope
+
+      seen = {}.compare_by_identity
+      scope.images.each do |img|
+        next if seen[img]
+
+        seen[img] = true
+        next if scope.keep?(img)
+
+        destroy_safely(img)
+      end
+      nil
+    end
+
+    def destroy_safely(img)
+      return unless img
+      return if img.respond_to?(:destroyed?) && img.destroyed?
+
+      img.destroy!
+    rescue ::Magick::ImageMagickError
+      # Swallow Magick-side destroy errors (e.g. DestroyedImageError on races);
+      # the goal is to free what we can without raising from `ensure`. Other
+      # exceptions (NoMethodError, ArgumentError, etc.) are intentionally not
+      # caught here so unrelated bugs surface early.
+      nil
+    end
+  end
+end

data/lib/rmagick_tidy/tracker.rb

@@ -0,0 +1,57 @@
+module RmagickTidy
+  module Tracker
+    module_function
+
+    def track(result, receiver = nil)
+      return result if receiver && result.equal?(receiver)
+
+      each_image(result) do |img|
+        register(img)
+      end
+      result
+    end
+
+    def keep(value)
+      scope = Registry.current
+      return unless scope
+
+      each_image(value) do |img|
+        scope.keep(img)
+      end
+    end
+
+    def each_image(value, &block)
+      case value
+      when nil
+        # nothing
+      when ->(v) { defined?(Magick::Image) && v.is_a?(Magick::Image) }
+        yield value
+      when ->(v) { defined?(Magick::ImageList) && v.is_a?(Magick::ImageList) }
+        value.each { |i| yield i if defined?(Magick::Image) && i.is_a?(Magick::Image) }
+      when Array
+        value.each { |v| each_image(v, &block) }
+      when Hash
+        value.each_value { |v| each_image(v, &block) }
+      end
+    end
+
+    def register(img)
+      scope = Registry.current
+      if scope
+        scope.register(img)
+      else
+        handle_out_of_scope(img)
+      end
+    end
+
+    def handle_out_of_scope(img)
+      case RmagickTidy.configuration.strict_mode
+      when :raise
+        raise OutOfScopeError,
+              "Magick::Image #{img.inspect} was created outside of RmagickTidy.scope"
+      when :warn
+        warn "[rmagick_tidy] Magick::Image created outside of RmagickTidy.scope (#{img.class})"
+      end
+    end
+  end
+end

data/lib/rmagick_tidy/version.rb

@@ -0,0 +1,3 @@
+module RmagickTidy
+  VERSION = "0.1.0".freeze
+end

data/lib/rmagick_tidy.rb

@@ -0,0 +1,32 @@
+require "rmagick"
+
+require "rmagick_tidy/version"
+require "rmagick_tidy/configuration"
+require "rmagick_tidy/registry"
+require "rmagick_tidy/tracker"
+require "rmagick_tidy/hook"
+
+module RmagickTidy
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def scope
+      Registry.push
+      result = yield
+      Tracker.keep(result)
+      result
+    ensure
+      Registry.pop_and_destroy
+    end
+  end
+end
+
+RmagickTidy::Hook.install!
+
+require "rmagick_tidy/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: rmagick_tidy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Junichiro Kasuya
+bindir: bin
+cert_chain: []
+date: 2026-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: simplecov-lcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: rmagick_tidy provides a scope block that automatically tracks every Magick::Image
+  / Magick::ImageList produced inside it and calls destroy! on them when the block
+  exits, so callers no longer need to litter their code with ensure + destroy! pairs.
+email:
+- junichiro.kasuya@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.ja.md
+- README.md
+- lib/rmagick_tidy.rb
+- lib/rmagick_tidy/configuration.rb
+- lib/rmagick_tidy/hook.rb
+- lib/rmagick_tidy/railtie.rb
+- lib/rmagick_tidy/registry.rb
+- lib/rmagick_tidy/tracker.rb
+- lib/rmagick_tidy/version.rb
+homepage: https://github.com/jksy/rmagick_tidy
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jksy/rmagick_tidy
+  source_code_uri: https://github.com/jksy/rmagick_tidy/tree/main
+  changelog_uri: https://github.com/jksy/rmagick_tidy/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/jksy/rmagick_tidy/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Automatic scope-based memory management for RMagick (Magick::Image).
+test_files: []