pura-image 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6eedafcbd9dfa1e520c478e6d48e6c370f05671f92af380e199f0532d52d7cd1
+  data.tar.gz: fa2410f3e26b984d8365abffa266e33fa8d98bca75d04fbc2e022b895cdf3705
+SHA512:
+  metadata.gz: b27e72e142ce3d4ab4ad618bb23e3c48393a6bb44fcbb723cf5fb2d28d6e07107a6985111116733f45bfd6d9d559d65276089684061903d81515c63351d243e5
+  data.tar.gz: 1ec0b0dd2e08635e7d9f96ff15832a730cef32250aac59026bc543ace8a65c9db6c0ae3ce2c957330a9e75d68affd5d75d0614528852e89fef0bf6ed1ccbffb1

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "pura-jpeg", path: "/tmp/pura-jpeg"
+gem "pura-png", path: "/tmp/pura-png"
+
+gem "rubocop", require: false

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 komagata
+
+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,160 @@
+# pura-image
+
+Pure Ruby image processing library with **zero C extension dependencies**. Bundles all **pura-*** format gems and provides an `ImageProcessing` adapter for Rails Active Storage.
+
+## Supported Formats
+
+| Format | Decode | Encode | Gem |
+|--------|--------|--------|-----|
+| JPEG | ✅ | ✅ | [pura-jpeg](https://github.com/komagata/pura-jpeg) |
+| PNG | ✅ | ✅ | [pura-png](https://github.com/komagata/pura-png) |
+| BMP | ✅ | ✅ | [pura-bmp](https://github.com/komagata/pura-bmp) |
+| GIF | ✅ | ✅ | [pura-gif](https://github.com/komagata/pura-gif) |
+| TIFF | ✅ | ✅ | [pura-tiff](https://github.com/komagata/pura-tiff) |
+| ICO/CUR | ✅ | ✅ | [pura-ico](https://github.com/komagata/pura-ico) |
+| WebP | ✅ | ✅ | [pura-webp](https://github.com/komagata/pura-webp) |
+
+Format auto-detection by magic bytes — no extension guessing needed for decode.
+
+## Installation
+
+```bash
+gem install pura-image
+```
+
+## Usage
+
+```ruby
+require "pura-image"
+
+# Load any format (auto-detected from magic bytes)
+image = Pura::Image.load("photo.jpg")
+image = Pura::Image.load("icon.webp")
+image.width   #=> 800
+image.height  #=> 600
+
+# Save to any format (detected from extension)
+Pura::Image.save(image, "output.png")
+
+# Convert between formats
+Pura::Image.convert("input.bmp", "output.jpg", quality: 85)
+Pura::Image.convert("photo.tiff", "photo.png")
+```
+
+## Image Operations
+
+All operations from the `image_processing` gem are supported:
+
+```ruby
+image = Pura::Image.load("photo.jpg")
+
+# Resize
+image.resize_to_limit(800, 600)   # downsize only, keep aspect ratio
+image.resize_to_fit(400, 400)     # resize to fit, keep aspect ratio
+image.resize_to_fill(400, 400)    # fill exact size, center crop excess
+image.resize_and_pad(400, 400)    # fit within bounds, pad with black
+image.resize_to_cover(400, 400)   # cover bounds, no crop
+
+# Transform
+image.crop(10, 10, 200, 200)      # crop region
+image.rotate(90)                   # rotate 90/180/270 degrees
+image.grayscale                    # convert to grayscale
+
+# Chain operations
+result = Pura::Image.load("photo.jpg")
+  .resize_to_limit(800, 600)
+  .rotate(90)
+  .grayscale
+
+Pura::Image.save(result, "thumb.jpg", quality: 80)
+```
+
+## Rails Active Storage Integration
+
+Drop-in replacement for libvips/ImageMagick:
+
+```ruby
+# Gemfile
+gem "image_processing"
+gem "pura-image"
+
+# config/application.rb
+config.active_storage.variant_processor = :pura
+```
+
+Models and views stay exactly the same:
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar do |attachable|
+    attachable.variant :thumb, resize_to_limit: [200, 200]
+  end
+end
+```
+
+```erb
+<%= image_tag user.avatar.variant(:thumb) %>
+```
+
+No `brew install vips`. No `apt install imagemagick`. Just `gem install` and go.
+
+### ImageProcessing::Pura API
+
+```ruby
+require "image_processing/pura"
+
+# Same API as ImageProcessing::Vips
+processed = ImageProcessing::Pura
+  .source("photo.jpg")
+  .resize_to_limit(400, 400)
+  .convert("png")
+  .call(destination: "output.png")
+
+# Pipeline branching
+pipeline = ImageProcessing::Pura.source("photo.jpg")
+large  = pipeline.resize_to_limit(800, 800).call(destination: "large.jpg")
+medium = pipeline.resize_to_limit(500, 500).call(destination: "medium.jpg")
+small  = pipeline.resize_to_limit(300, 300).call(destination: "small.jpg")
+
+# Validation
+ImageProcessing::Pura.valid_image?("photo.jpg")  #=> true
+```
+
+## Benchmark
+
+400×400 image, Ruby 4.0.2 + YJIT vs ffmpeg (C + SIMD).
+
+### Decode
+
+| Format | pura-* | ffmpeg | vs ffmpeg |
+|--------|--------|--------|-----------|
+| TIFF | **14 ms** | 59 ms | 🚀 **4× faster** |
+| BMP | **39 ms** | 59 ms | 🚀 **1.5× faster** |
+| GIF | 77 ms | 65 ms | ~1× (comparable) |
+| PNG | 111 ms | 60 ms | 1.9× slower |
+| WebP | 207 ms | 66 ms | 3.1× slower |
+| JPEG | 304 ms | 55 ms | 5.5× slower |
+
+### Encode
+
+| Format | pura-* | ffmpeg | vs ffmpeg |
+|--------|--------|--------|-----------|
+| TIFF | **0.8 ms** | 58 ms | 🚀 **73× faster** |
+| BMP | **35 ms** | 58 ms | 🚀 **1.7× faster** |
+| PNG | **52 ms** | 61 ms | 🚀 **faster** |
+| JPEG | 238 ms | 62 ms | 3.8× slower |
+| GIF | 377 ms | 59 ms | 6.4× slower |
+
+5 out of 11 operations are **faster than C** (ffmpeg process-spawn overhead).
+
+## Why pure Ruby?
+
+- **`gem install` and go** — no `brew install`, no `apt install`, no C compiler
+- **Works everywhere Ruby works** — CRuby, ruby.wasm, mruby, JRuby, TruffleRuby
+- **Edge/Wasm ready** — browsers (ruby.wasm), sandboxed environments, no system libraries needed
+- **Perfect for dev/CI** — no ImageMagick/libvips setup. `rails new` → image upload → it just works
+- **7 formats, 1 interface** — unified API across JPEG, PNG, BMP, GIF, TIFF, ICO, WebP
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,8 @@
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.test_files = FileList["test/test_*.rb"]
+end
+
+task default: :test

data/lib/image_processing/pura.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "image_processing"
+
+require_relative "../pura-image"
+
+module ImageProcessing
+  module Pura
+    extend Chainable
+
+    def self.valid_image?(file)
+      path = file.respond_to?(:path) ? file.path : file.to_s
+      data = File.binread(path, 8)
+      format = ::Pura::Image::Processor.detect_format(data)
+      return false unless format
+
+      ::Pura::Image::Processor.load(path)
+      true
+    rescue StandardError
+      false
+    end
+
+    class Processor < ImageProcessing::Processor
+      accumulator :image, ::Pura::Image::Wrapper
+
+      def self.supports_resize_on_load?
+        false
+      end
+
+      def self.load_image(path_or_image, **_options)
+        if path_or_image.is_a?(::Pura::Image::Wrapper)
+          path_or_image
+        elsif path_or_image.is_a?(String)
+          ::Pura::Image::Processor.load(path_or_image)
+        elsif path_or_image.respond_to?(:path)
+          ::Pura::Image::Processor.load(path_or_image.path)
+        else
+          raise ImageProcessing::Error, "unsupported source: #{path_or_image.inspect}"
+        end
+      end
+
+      def self.save_image(wrapper, destination, **options)
+        ::Pura::Image::Processor.save(wrapper, destination.to_s, **options)
+      end
+
+      def resize_to_limit(width, height, **_options)
+        w = image.width
+        h = image.height
+
+        return image if w <= (width || w) && h <= (height || h)
+
+        width ||= w
+        height ||= h
+        image.resize_to_fit(width, height)
+      end
+
+      def resize_to_fit(width, height, **_options)
+        width ||= image.width
+        height ||= image.height
+        image.resize_to_fit(width, height)
+      end
+
+      def resize_to_fill(width, height, **_options)
+        image.resize_to_fill(width, height)
+      end
+
+      def resize_and_pad(width, height, background: nil, **_options)
+        bg = background || [0, 0, 0]
+        image.resize_and_pad(width, height, background: bg)
+      end
+
+      def resize_to_cover(width, height, **_options)
+        image.resize_to_cover(width, height)
+      end
+
+      def crop(left, top, width, height, **_options)
+        image.crop(left, top, width, height)
+      end
+
+      def rotate(degrees, **_options)
+        image.rotate(degrees)
+      end
+
+      def colourspace(space, **_options)
+        if %w[b-w grey16].include?(space.to_s)
+          image.grayscale
+        else
+          image
+        end
+      end
+
+      def strip(**_options)
+        image.strip
+      end
+
+      def convert(format, **_options)
+        # Store desired format for save_image
+        @format = format.to_s.delete(".")
+        image
+      end
+    end
+  end
+end

data/lib/pura/image/operations.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Pura
+  module Image
+    module Operations
+      def rotate(degrees)
+        case degrees % 360
+        when 0
+          dup_image
+        when 90
+          rotate90
+        when 180
+          rotate180
+        when 270
+          rotate270
+        else
+          raise ArgumentError, "Only 90, 180, 270 degree rotations are supported"
+        end
+      end
+
+      def grayscale
+        new_pixels = String.new(encoding: Encoding::BINARY, capacity: @pixels.bytesize)
+        i = 0
+        size = @pixels.bytesize
+        while i < size
+          r = @pixels.getbyte(i)
+          g = @pixels.getbyte(i + 1)
+          b = @pixels.getbyte(i + 2)
+          gray = ((r + g + b) / 3.0).round
+          new_pixels << gray << gray << gray
+          i += 3
+        end
+        self.class.new(@width, @height, new_pixels)
+      end
+
+      def resize_to_limit(max_width, max_height)
+        return dup_image if @width <= max_width && @height <= max_height
+
+        scale = [@width.to_f / max_width, @height.to_f / max_height].max
+        new_w = [(@width / scale).round, 1].max
+        new_h = [(@height / scale).round, 1].max
+        resize(new_w, new_h)
+      end
+
+      def resize_to_fit(max_width, max_height)
+        scale = [@width.to_f / max_width, @height.to_f / max_height].max
+        new_w = [(@width / scale).round, 1].max
+        new_h = [(@height / scale).round, 1].max
+        resize(new_w, new_h)
+      end
+
+      def resize_to_fill(fill_width, fill_height)
+        resize_fill(fill_width, fill_height)
+      end
+
+      def resize_and_pad(target_width, target_height, background: [0, 0, 0])
+        # First resize_to_fit
+        scale = [@width.to_f / target_width, @height.to_f / target_height].max
+        new_w = [(@width / scale).round, 1].max
+        new_h = [(@height / scale).round, 1].max
+        resized = resize(new_w, new_h)
+
+        # Create padded canvas
+        r, g, b = background
+        bg_row = (String.new(encoding: Encoding::BINARY) << r << g << b) * target_width
+        canvas = bg_row * target_height
+
+        # Center the resized image on the canvas
+        offset_x = (target_width - resized.width) / 2
+        offset_y = (target_height - resized.height) / 2
+
+        resized.height.times do |y|
+          src_start = y * resized.width * 3
+          dst_start = (((offset_y + y) * target_width) + offset_x) * 3
+          canvas[dst_start, resized.width * 3] = resized.pixels[src_start, resized.width * 3]
+        end
+
+        self.class.new(target_width, target_height, canvas)
+      end
+
+      def resize_to_cover(cover_width, cover_height)
+        scale = [@width.to_f / cover_width, @height.to_f / cover_height].min
+        new_w = [(@width / scale).round, 1].max
+        new_h = [(@height / scale).round, 1].max
+        resize(new_w, new_h)
+      end
+
+      def strip
+        dup_image
+      end
+
+      private
+
+      def dup_image
+        self.class.new(@width, @height, @pixels.dup)
+      end
+
+      def rotate90
+        new_w = @height
+        new_h = @width
+        new_pixels = String.new(encoding: Encoding::BINARY, capacity: new_w * new_h * 3)
+
+        new_h.times do |y|
+          new_w.times do |x|
+            # (x, y) in new image comes from (y, height-1-x) in old image
+            src_offset = (((@height - 1 - x) * @width) + y) * 3
+            new_pixels << @pixels[src_offset, 3]
+          end
+        end
+        self.class.new(new_w, new_h, new_pixels)
+      end
+
+      def rotate180
+        new_pixels = String.new(encoding: Encoding::BINARY, capacity: @pixels.bytesize)
+        (@height - 1).downto(0) do |y|
+          (@width - 1).downto(0) do |x|
+            offset = ((y * @width) + x) * 3
+            new_pixels << @pixels[offset, 3]
+          end
+        end
+        self.class.new(@width, @height, new_pixels)
+      end
+
+      def rotate270
+        new_w = @height
+        new_h = @width
+        new_pixels = String.new(encoding: Encoding::BINARY, capacity: new_w * new_h * 3)
+
+        new_h.times do |y|
+          new_w.times do |x|
+            # (x, y) in new image comes from (width-1-y, x) in old image
+            src_offset = ((x * @width) + (@width - 1 - y)) * 3
+            new_pixels << @pixels[src_offset, 3]
+          end
+        end
+        self.class.new(new_w, new_h, new_pixels)
+      end
+    end
+  end
+end

data/lib/pura/image/processor.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Pura
+  module Image
+    class Processor
+      MAGIC_BYTES = {
+        jpeg: [0xFF, 0xD8],
+        png: [0x89, 0x50, 0x4E, 0x47],
+        gif: [0x47, 0x49, 0x46],           # "GIF"
+        bmp: [0x42, 0x4D],                 # "BM"
+        tiff_le: [0x49, 0x49, 0x2A, 0x00], # "II*\0" little-endian
+        tiff_be: [0x4D, 0x4D, 0x00, 0x2A], # "MM\0*" big-endian
+        webp: [0x52, 0x49, 0x46, 0x46],    # "RIFF" (+ "WEBP" at offset 8)
+        ico: [0x00, 0x00, 0x01, 0x00],     # ICO
+        cur: [0x00, 0x00, 0x02, 0x00]      # CUR
+      }.freeze
+
+      EXTENSION_MAP = {
+        ".jpg" => :jpeg, ".jpeg" => :jpeg,
+        ".png" => :png,
+        ".bmp" => :bmp,
+        ".gif" => :gif,
+        ".tif" => :tiff, ".tiff" => :tiff,
+        ".webp" => :webp,
+        ".ico" => :ico,
+        ".cur" => :ico
+      }.freeze
+
+      class << self
+        def detect_format(data)
+          bytes = data.bytes
+
+          return :jpeg if bytes[0] == 0xFF && bytes[1] == 0xD8
+          return :png if bytes[0..3] == MAGIC_BYTES[:png]
+          return :gif if bytes[0..2] == MAGIC_BYTES[:gif]
+          return :bmp if bytes[0..1] == MAGIC_BYTES[:bmp]
+          return :tiff if bytes[0..3] == MAGIC_BYTES[:tiff_le] || bytes[0..3] == MAGIC_BYTES[:tiff_be]
+          return :ico if bytes[0..3] == MAGIC_BYTES[:ico] || bytes[0..3] == MAGIC_BYTES[:cur]
+
+          if bytes[0..3] == MAGIC_BYTES[:webp] && bytes.length >= 12 && (bytes[8..11] == [0x57, 0x45, 0x42, 0x50])
+            return :webp # "WEBP"
+          end
+
+          raise ArgumentError, "Unsupported image format"
+        end
+
+        def detect_format_by_extension(path)
+          ext = File.extname(path).downcase
+          EXTENSION_MAP[ext] || raise(ArgumentError, "Unsupported file extension: #{ext}")
+        end
+
+        def load(path)
+          data = File.binread(path, 16)
+          format = detect_format(data)
+          image = decode_with_format(path, format)
+          wrap(image)
+        end
+
+        def save(image, path, **options)
+          format = detect_format_by_extension(path)
+          raw_image = unwrap(image)
+          encode_with_format(raw_image, path, format, **options)
+        end
+
+        def convert(input_path, output_path, **options)
+          image = load(input_path)
+          save(image, output_path, **options)
+        end
+
+        def wrap(raw_image)
+          Wrapper.new(raw_image.width, raw_image.height, raw_image.pixels.dup)
+        end
+
+        def unwrap(wrapper)
+          Pura::Jpeg::Image.new(wrapper.width, wrapper.height, wrapper.pixels)
+        end
+
+        private
+
+        def decode_with_format(path, format)
+          case format
+          when :jpeg then Pura::Jpeg.decode(path)
+          when :png  then Pura::Png.decode(path)
+          when :bmp  then Pura::Bmp.decode(path)
+          when :gif  then Pura::Gif.decode(path)
+          when :tiff then Pura::Tiff.decode(path)
+          when :ico  then Pura::Ico.decode(path)
+          when :webp
+            raise ArgumentError, "WebP support not available" unless defined?(Pura::Webp)
+
+            Pura::Webp.decode(path)
+          else
+            raise ArgumentError, "Unsupported format: #{format}"
+          end
+        end
+
+        def encode_with_format(image, path, format, **options)
+          case format
+          when :jpeg
+            Pura::Jpeg.encode(image, path, quality: options.fetch(:quality, 85))
+          when :png
+            png_img = Pura::Png::Image.new(image.width, image.height, image.pixels)
+            Pura::Png.encode(png_img, path, compression: options.fetch(:compression, 6))
+          when :bmp
+            bmp_img = Pura::Bmp::Image.new(image.width, image.height, image.pixels)
+            Pura::Bmp.encode(bmp_img, path)
+          when :gif
+            gif_img = Pura::Gif::Image.new(image.width, image.height, image.pixels)
+            Pura::Gif.encode(gif_img, path)
+          when :tiff
+            tiff_img = Pura::Tiff::Image.new(image.width, image.height, image.pixels)
+            Pura::Tiff.encode(tiff_img, path)
+          when :ico
+            ico_img = Pura::Ico::Image.new(image.width, image.height, image.pixels)
+            Pura::Ico.encode(ico_img, path)
+          when :webp
+            raise ArgumentError, "WebP encoding not available" unless defined?(Pura::Webp)
+
+            webp_img = Pura::Webp::Image.new(image.width, image.height, image.pixels)
+            Pura::Webp.encode(webp_img, path, **options)
+          else
+            raise ArgumentError, "Unsupported output format: #{format}"
+          end
+        end
+      end
+    end
+
+    class Wrapper
+      include Operations
+
+      attr_reader :width, :height, :pixels
+
+      def initialize(width, height, pixels)
+        @width = width
+        @height = height
+        @pixels = pixels.dup
+        @pixels.force_encoding(Encoding::BINARY)
+      end
+
+      def pixel_at(x, y)
+        raise IndexError, "Coordinates out of bounds" if x.negative? || x >= @width || y.negative? || y >= @height
+
+        offset = ((y * @width) + x) * 3
+        [@pixels.getbyte(offset), @pixels.getbyte(offset + 1), @pixels.getbyte(offset + 2)]
+      end
+
+      def to_rgb_array
+        result = []
+        i = 0
+        size = @pixels.bytesize
+        while i < size
+          result << [@pixels.getbyte(i), @pixels.getbyte(i + 1), @pixels.getbyte(i + 2)]
+          i += 3
+        end
+        result
+      end
+
+      def to_ppm
+        "P6\n#{@width} #{@height}\n255\n" + @pixels
+      end
+
+      def resize(new_width, new_height)
+        raw = Pura::Jpeg::Image.new(@width, @height, @pixels)
+        resized = raw.resize(new_width, new_height)
+        self.class.new(resized.width, resized.height, resized.pixels)
+      end
+
+      def resize_fit(max_width, max_height)
+        raw = Pura::Jpeg::Image.new(@width, @height, @pixels)
+        fitted = raw.resize_fit(max_width, max_height)
+        self.class.new(fitted.width, fitted.height, fitted.pixels)
+      end
+
+      def resize_fill(fill_width, fill_height)
+        raw = Pura::Jpeg::Image.new(@width, @height, @pixels)
+        filled = raw.resize_fill(fill_width, fill_height)
+        self.class.new(filled.width, filled.height, filled.pixels)
+      end
+
+      def crop(x, y, w, h)
+        raw = Pura::Jpeg::Image.new(@width, @height, @pixels)
+        cropped = raw.crop(x, y, w, h)
+        self.class.new(cropped.width, cropped.height, cropped.pixels)
+      end
+    end
+  end
+end

data/lib/pura/image/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pura
+  module Image
+    VERSION = "0.1.0"
+  end
+end

data/lib/pura-image.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "pura-jpeg"
+require "pura-png"
+require "pura-bmp"
+require "pura-gif"
+require "pura-tiff"
+require "pura-ico"
+begin
+  require "pura-webp"
+rescue LoadError
+  # pura-webp is optional
+end
+
+require_relative "pura/image/version"
+require_relative "pura/image/operations"
+require_relative "pura/image/processor"
+
+module Pura
+  module Image
+    class << self
+      def load(path)
+        Processor.load(path)
+      end
+
+      def save(image, path, **options)
+        Processor.save(image, path, **options)
+      end
+
+      def convert(input_path, output_path, **options)
+        Processor.convert(input_path, output_path, **options)
+      end
+
+      def detect_format(data)
+        Processor.detect_format(data)
+      end
+
+      def supported_formats
+        formats = %i[jpeg png bmp gif tiff ico]
+        formats << :webp if defined?(Pura::Webp)
+        formats
+      end
+    end
+  end
+end

data/pura-image.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "lib/pura/image/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "pura-image"
+  spec.version = Pura::Image::VERSION
+  spec.authors = ["komagata"]
+  spec.email = ["komagata@gmail.com"]
+
+  spec.summary = "Pure Ruby image processing library"
+  spec.description = "Unified image processing library bundling all pura-* format gems " \
+                     "with image_processing gem compatible API for Rails Active Storage."
+  spec.homepage = "https://github.com/komagata/pura-image"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files = Dir["lib/**/*.rb"] + ["pura-image.gemspec", "Gemfile", "Rakefile", "README.md", "LICENSE"]
+
+  spec.add_dependency "pura-jpeg", "~> 0.1"
+  spec.add_dependency "pura-png", "~> 0.1"
+  spec.add_dependency "pura-bmp", "~> 0.1"
+  spec.add_dependency "pura-gif", "~> 0.1"
+  spec.add_dependency "pura-tiff", "~> 0.1"
+  spec.add_dependency "pura-ico", "~> 0.1"
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: pura-image
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- komagata
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pura-jpeg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pura-png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pura-bmp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pura-gif
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pura-tiff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pura-ico
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !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'
+description: Unified image processing library bundling all pura-* format gems with
+  image_processing gem compatible API for Rails Active Storage.
+email:
+- komagata@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/image_processing/pura.rb
+- lib/pura-image.rb
+- lib/pura/image/operations.rb
+- lib/pura/image/processor.rb
+- lib/pura/image/version.rb
+- pura-image.gemspec
+homepage: https://github.com/komagata/pura-image
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/komagata/pura-image
+  source_code_uri: https://github.com/komagata/pura-image
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Pure Ruby image processing library
+test_files: []