placeholder-image 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1b9fc489b1812d0f1f82cbc9bfa765d6e01cdba612da2697a416bbcbc460ae0e
+  data.tar.gz: 1e0d6fe2e8fd81ca37bad24219771fd4125190e92d1f0a9cdc0b216b526ef7d5
+SHA512:
+  metadata.gz: 28682fa1cfa37908f42663ba841ff50de20dcb578d7cbeabd8eb09b46e32bd67b92d1d2cabcb8010d1a1cba1469f3de68b43b690b0858fbcb5f65797a749d236
+  data.tar.gz: ddd2662d54dbdf2bd81125763a3ccf9cf4c927e57e32a2952cab2e47f76f446f13ffa3c959b9ceab41d04a19443a552f1c6a8a4e38868fc9ec8c4e9d1337a877

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+All notable changes to this project will be documented here. This project follows
+[Semantic Versioning](https://semver.org/).
+
+## v1.0.0 - 2026-08-05
+
+  - Initial release. Includes PNG-generating Rack middleware, stand-alone Docker service, and complete examples of integrating with Sinatra, Rails, and generic Rack applications.
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rodney Waldhoff and Placeholder Image contributors
+
+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,107 @@
+# Placeholder Image
+
+A dependency-light Rack middleware that generates simple placeholder images in pure Ruby (stdlib zlib only, no image gem dependencies). 
+
+[![CI](https://github.com/rodw/placeholder-image-rb/actions/workflows/ci.yml/badge.svg)](https://github.com/rodw/placeholder-image-rb/actions/workflows/ci.yml)
+[![Gem Version](https://img.shields.io/gem/v/placeholder-image)](https://rubygems.org/gems/placeholder-image)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.2-CC342D)](https://www.ruby-lang.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE.txt)
+
+<p>
+  <img
+    src="https://raw.githubusercontent.com/rodw/placeholder-image-rb/main/examples/images/example-100x160.png"
+    alt="A 100 by 160 pixel placeholder using the default colors"
+    width="100"
+    align="middle"
+    title="/placeholder/100x160.png">
+  <img
+    src="https://raw.githubusercontent.com/rodw/placeholder-image-rb/main/examples/images/example-640x360-bg1D3557-fgF1FAEE.png"
+    alt="A 640 by 360 pixel placeholder with custom colors"
+    width="320"
+    align="middle"
+    title="/placeholder/640x360.png?bg=1d3557&fg=f1faee">
+  <img
+    src="https://raw.githubusercontent.com/rodw/placeholder-image-rb/main/examples/images/example-120-bg000-fgF90.png"
+    alt="A 120-pixel square placeholder with custom colors"
+    width="120"
+    align="middle"
+    title="/placeholder/120.png?bg=000&fg=f90">
+</p>
+
+## Installation
+
+Placeholder-Image requires Ruby 3.2+ and Rack 3.
+
+Add it to your bundle:
+
+```ruby
+gem "placeholder-image"
+```
+
+Then install:
+
+```sh
+bundle install
+```
+
+## Using
+
+Placeholder-Image runs as standard Rack middleware:
+
+```ruby
+require "placeholder_image"
+
+use PlaceholderImage::Middleware, path_prefix: "/placeholder"
+run MyApp
+```
+
+The URL path specifies a square or rectangular image, with optional background and foreground colors as 3- or 6-digit hex codes:
+
+```text
+/placeholder/300.png
+/placeholder/640x480.png
+/placeholder/640x480.png?bg=eee&fg=1d3557
+```
+
+See [the examples](https://github.com/rodw/placeholder-image-rb/tree/main/examples) for complete demonstrations of integrating placeholder-image with Sinatra, Rails, and vanilla Rack applications.
+
+## Configuration
+
+Pass configuration options as keyword arguments when adding the middleware:
+
+```ruby
+use PlaceholderImage::Middleware,
+    path_prefix: "/placeholder",
+    http_header_cache_control: "public, max-age=31536000, immutable",
+    image_max_dim_px: 4_000,
+    image_max_total_px: 4_000 * 4_000,
+    image_default_bg: "#eeeeee",
+    image_default_fg: "#909",
+    cache_max_entries: 128
+```
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `path_prefix` | `/placeholder` | URL path prefix under which generated images are served. For example, the default serves `/placeholder/300.png`. A trailing slash is optional. |
+| `http_header_cache_control` | `public, max-age=31536000, immutable` | Value of the `Cache-Control` response header. The default allows public caches to retain an image for one year. |
+| `image_max_dim_px` | `4000` | Maximum permitted width or height, in pixels. Requests exceeding this limit return `400 Bad Request`. |
+| `image_max_total_px` | `16000000` | Maximum permitted total pixel count (`width * height`). This limits the CPU time and memory consumed by a single image. Requests exceeding this limit return `400 Bad Request`. |
+| `image_default_bg` | `[0xEE,0xEE,0xEE]` | Default background color as an RGB byte array or a 3- or 6-digit hex string, optionally beginning with `#`. The request's `bg` parameter overrides it. |
+| `image_default_fg` | `[0x99,0x99,0x99]`| Default foreground color used for the border and dimension label. It accepts the same array and hex-string formats as `image_default_bg`; the request's `fg` parameter overrides it. |
+| `cache_max_entries` | `128` | Maximum number of generated images retained in each middleware instance's in-memory FIFO cache. Set to `0` to disable caching. |
+
+
+## Running as a Stand-Alone Container
+
+Placeholder-Image can be run as a stand-alone, containerized service. 
+
+See the [Docker server documentation](https://github.com/rodw/placeholder-image-rb/blob/main/docker/README.md) for details.
+
+## Development
+
+For development setup and contribution guidelines, see
+[CONTRIBUTING.md](https://github.com/rodw/placeholder-image-rb/blob/main/CONTRIBUTING.md).
+
+## License
+
+Placeholder-Image is available under the [MIT License](https://github.com/rodw/placeholder-image-rb/blob/main/LICENSE.txt).

data/lib/placeholder_image/middleware.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "uri"
+require "digest"
+
+# Rack middleware that serves generated placeholder PNGs.
+#
+#   use PlaceholderImage::Middleware, path_prefix: "/placeholder"
+#
+# Examples:
+#   GET /placeholder/300.png             -> 300x300, default colors
+#   GET /placeholder/640x480.png         -> 640x480, default colors
+#   GET /placeholder/300x200.png?bg=eee&fg=999 -> 300x200, specified colors
+#
+# No image gems required: PNGs are encoded with stdlib zlib.
+module PlaceholderImage
+  class BadRequest < StandardError; end
+
+  # ------------------------------------------------------------- Middleware --
+  class Middleware
+    DEFAULTS = {
+      path_prefix: "/placeholder",
+      image_max_dim_px: 4_000,
+      image_max_total_px: 4_000 * 4_000,
+      http_header_cache_control: "public, max-age=31536000, immutable",
+      cache_max_entries: 128,
+      image_default_bg: [0xEE, 0xEE, 0xEE],
+      image_default_fg: [0x99, 0x99, 0x99]
+    }.freeze
+
+    DIMENSION = /[1-9]\d*/
+
+    # @param app [#call] the downstream Rack application.
+    # @param options [Hash] configuration overrides merged over {DEFAULTS}.
+    # @option options [String] :path_prefix ("/placeholder") URL prefix the middleware serves.
+    # @option options [Integer] :image_max_dim_px (4000) maximum width or height, in pixels.
+    # @option options [Integer] :image_max_total_px (16_000_000) maximum total pixel count.
+    # @option options [String] :http_header_cache_control the +Cache-Control+ response header value.
+    # @option options [Integer] :cache_max_entries (128) in-memory FIFO cache size; +0+ disables caching.
+    # @option options [Array(Integer, Integer, Integer), String] :image_default_bg default background color.
+    # @option options [Array(Integer, Integer, Integer), String] :image_default_fg default foreground color.
+    def initialize(app, **options)
+      @app     = app
+      @options = DEFAULTS.merge(options)
+      @cache   = {}
+      @mutex   = Mutex.new
+
+      path_prefix = Regexp.escape(@options[:path_prefix].chomp("/"))
+      @owned = %r{\A#{path_prefix}(?:[./]|\z)}
+      @route = %r{\A#{path_prefix}/(#{DIMENSION})(?:x(#{DIMENSION}))?\.png\z}
+    end
+
+    # Rack entry point. Serves a PNG for owned paths and delegates everything else downstream.
+    #
+    # @param env [Hash] the Rack environment.
+    # @return [Array(Integer, Hash, Array)] a Rack response tuple.
+    def call(env)
+      return @app.call(env) unless @owned.match?(env["PATH_INFO"])
+      return error(env["REQUEST_METHOD"], 405, "method not allowed") unless %w[GET HEAD].include?(env["REQUEST_METHOD"])
+
+      spec = parse(env["PATH_INFO"], env["QUERY_STRING"].to_s)
+      etag = etag_for(spec)
+      return [304, cache_headers(etag), []] if fresh?(env, etag)
+
+      img  = fetch(spec)
+      body = env["REQUEST_METHOD"] == "HEAD" ? [] : [img]
+
+      [200, cache_headers(etag).merge(
+        "content-type" => "image/png",
+        "content-length" => img.bytesize.to_s
+      ), body]
+    rescue BadRequest => e
+      error(env["REQUEST_METHOD"], 400, e.message)
+    end
+
+    private
+
+    def cache_headers(etag)
+      { "etag" => etag,
+        "cache-control" => @options[:http_header_cache_control] }
+    end
+
+    def fresh?(env, etag)
+      env["HTTP_IF_NONE_MATCH"].to_s.split(",").map(&:strip).include?(etag)
+    end
+
+    def etag_for(spec)
+      %("#{Digest::SHA256.hexdigest(spec.inspect)[0, 16]}")
+    end
+
+    def error(req_method, status, message)
+      body = req_method == "HEAD" ? "" : "#{message}\n"
+
+      [
+        status,
+        { "content-type" => "text/plain; charset=utf-8",
+          "content-length" => body.bytesize.to_s },
+        [body]
+      ]
+    end
+
+    def fetch(spec)
+      @mutex.synchronize { return @cache[spec] if @cache.key?(spec) }
+
+      img = Renderer.call(**spec)
+
+      @mutex.synchronize do
+        @cache[spec] = img if @options[:cache_max_entries].positive?
+        @cache.shift while @cache.size > @options[:cache_max_entries] # FIFO eviction
+      end
+
+      img
+    end
+
+    def parse(path, query)
+      width, height = parse_dimensions(path)
+      params = parse_query_string(query)
+
+      { width: width,
+        height: height,
+        bg: parse_color(params["bg"], @options[:image_default_bg]),
+        fg: parse_color(params["fg"], @options[:image_default_fg]),
+        text: "#{width}x#{height}" }
+    end
+
+    def parse_dimensions(path)
+      match = @route.match(path) or
+        raise BadRequest, "no such image; expected #{@options[:path_prefix]}/<SIZE>.png or " \
+                          "#{@options[:path_prefix]}/<W>x<H>.png"
+
+      width  = match[1].to_i
+      height = (match[2] || match[1]).to_i
+      max    = @options[:image_max_dim_px]
+
+      raise BadRequest, "dimensions must be between 1 and #{max}" if width > max || height > max
+      raise BadRequest, "image exceeds #{@options[:image_max_total_px]} pixels" if
+        width * height > @options[:image_max_total_px]
+
+      [width, height]
+    end
+
+    def parse_query_string(query)
+      return {} if query.empty?
+
+      URI.decode_www_form(query).to_h
+    rescue ArgumentError
+      raise BadRequest, "malformed query string"
+    end
+
+    def parse_color(value, default)
+      value = default if value.nil? || value.empty?
+      return value if value.is_a?(Array)
+
+      hex = value.delete_prefix("#")
+      hex = hex.chars.map { |c| c * 2 }.join if hex.length == 3
+      raise BadRequest, "invalid color: #{value}" unless hex.match?(/\A\h{6}\z/)
+
+      [hex[0, 2], hex[2, 2], hex[4, 2]].map { |pair| pair.to_i(16) }
+    end
+  end
+end

data/lib/placeholder_image/renderer.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module PlaceholderImage
+  # Generates a placeholder PNG from dimensions, colors, and label text.
+  module Renderer
+    LABEL_WIDTH_PCT = 0.80
+    LABEL_HEIGHT_PCT = 0.50
+
+    # Minimal 8-bit truecolor PNG encoder.
+    class Canvas
+      SIGNATURE = "\x89PNG\r\n\x1A\n".b
+
+      attr_reader :width, :height
+
+      def initialize(width, height, rgb)
+        @width = width
+        @height = height
+        @row_bytes = width * 3
+        @data = (rgb.pack("C3") * (width * height)).b
+      end
+
+      def []=(x, y, rgb)
+        return unless x.between?(0, @width - 1) && y.between?(0, @height - 1)
+
+        i = ((y * @width) + x) * 3
+        @data.setbyte(i, rgb[0])
+        @data.setbyte(i + 1, rgb[1])
+        @data.setbyte(i + 2, rgb[2])
+      end
+
+      def fill_rect(x, y, width, height, rgb)
+        y.upto(y + height - 1) do |py|
+          x.upto(x + width - 1) { |px| self[px, py] = rgb }
+        end
+      end
+
+      def to_png
+        raw = String.new(capacity: (@row_bytes + 1) * @height, encoding: Encoding::BINARY)
+        @height.times { |y| raw << 0.chr << @data.byteslice(y * @row_bytes, @row_bytes) }
+        ihdr = [@width, @height, 8, 2, 0, 0, 0].pack("NNC5") # 8-bit, color type 2 (RGB)
+
+        SIGNATURE +
+          chunk("IHDR", ihdr) +
+          chunk("IDAT", Zlib::Deflate.deflate(raw, Zlib::BEST_SPEED)) +
+          chunk("IEND", "".b)
+      end
+
+      private
+
+      def chunk(type, data)
+        type = type.b
+        [data.bytesize].pack("N") + type + data + [Zlib.crc32(type + data)].pack("N")
+      end
+    end
+
+    # 5x7 bitmap font, just enough to render dimension labels such as "1024x768".
+    module Font
+      FONT_WIDTH = 5
+      FONT_HEIGHT = 7
+
+      GLYPHS = {
+        "0" => %w[01110 10001 10011 10101 11001 10001 01110],
+        "1" => %w[00100 01100 00100 00100 00100 00100 01110],
+        "2" => %w[01110 10001 00001 00010 00100 01000 11111],
+        "3" => %w[11111 00010 00100 00010 00001 10001 01110],
+        "4" => %w[00010 00110 01010 10010 11111 00010 00010],
+        "5" => %w[11111 10000 11110 00001 00001 10001 01110],
+        "6" => %w[00110 01000 10000 11110 10001 10001 01110],
+        "7" => %w[11111 00001 00010 00100 01000 01000 01000],
+        "8" => %w[01110 10001 10001 01110 10001 10001 01110],
+        "9" => %w[01110 10001 10001 01111 00001 00010 01100],
+        "x" => %w[00000 00000 10001 01010 00100 01010 10001]
+      }.freeze
+
+      def self.advance(scale) = (FONT_WIDTH + 1) * scale
+      def self.text_width(text, scale) = text.empty? ? 0 : (advance(scale) * text.length) - scale
+
+      def self.draw(canvas, text, x, y, scale, color)
+        text.each_char.with_index do |char, i|
+          glyph = GLYPHS[char] or next
+          ox = x + (advance(scale) * i)
+          glyph.each_with_index do |row, ry|
+            row.each_char.with_index do |bit, rx|
+              next if bit == "0"
+
+              canvas.fill_rect(ox + (rx * scale), y + (ry * scale), scale, scale, color)
+            end
+          end
+        end
+      end
+    end
+
+    module_function
+
+    # Render a placeholder PNG.
+    #
+    # @param width [Integer] image width in pixels.
+    # @param height [Integer] image height in pixels.
+    # @param bg [Array(Integer, Integer, Integer)] background color as RGB bytes.
+    # @param fg [Array(Integer, Integer, Integer)] foreground color, used for the border and label.
+    # @param text [String] label drawn centered on the image (digits and "x" only).
+    # @return [String] binary PNG data.
+    # @example
+    #   Renderer.call(width: 320, height: 240, bg: [238, 238, 238], fg: [153, 153, 153], text: "320x240")
+    def call(width:, height:, bg:, fg:, text:)
+      canvas = Canvas.new(width, height, bg)
+      draw_border(canvas, fg)
+      draw_label(canvas, text, fg)
+      canvas.to_png
+    end
+
+    def draw_border(canvas, color)
+      width = canvas.width
+      height = canvas.height
+      thickness = ([width, height].min / 40).clamp(1, 6)
+      return if width < 4 * thickness || height < 4 * thickness
+
+      canvas.fill_rect(0, 0, width, thickness, color)
+      canvas.fill_rect(0, height - thickness, width, thickness, color)
+      canvas.fill_rect(0, 0, thickness, height, color)
+      canvas.fill_rect(width - thickness, 0, thickness, height, color)
+    end
+
+    def draw_label(canvas, text, color)
+      return if text.empty?
+
+      natural_width = Font.text_width(text, 1)
+      scale = [(canvas.width * LABEL_WIDTH_PCT / natural_width).floor,
+               (canvas.height * LABEL_HEIGHT_PCT / Font::FONT_HEIGHT).floor].min
+      return if scale < 1
+
+      Font.draw(canvas,
+                text,
+                (canvas.width - Font.text_width(text, scale)) / 2,
+                (canvas.height - (Font::FONT_HEIGHT * scale)) / 2,
+                scale,
+                color)
+    end
+
+    private_class_method :draw_border, :draw_label
+
+    private_constant :Canvas, :Font
+  end
+end

data/lib/placeholder_image/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PlaceholderImage
+  VERSION = "1.0.0"
+end

data/lib/placeholder_image.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "placeholder_image/version"
+require_relative "placeholder_image/renderer"
+require_relative "placeholder_image/middleware"

data/sig/placeholder_image/middleware.rbs

@@ -0,0 +1,44 @@
+module PlaceholderImage
+  # Raised for any client error; converted to an HTTP 400 by the middleware.
+  class BadRequest < StandardError
+  end
+
+  # Rack middleware that serves generated placeholder PNGs.
+  class Middleware
+    type rack_response = [ Integer, Hash[String, String], Array[String] ]
+
+    DEFAULTS: Hash[Symbol, untyped]
+    DIMENSION: Regexp
+
+    @app: untyped
+    @options: Hash[Symbol, untyped]
+    @cache: Hash[untyped, untyped]
+    @mutex: Thread::Mutex
+    @owned: Regexp
+    @route: Regexp
+
+    def initialize: (untyped app, **untyped options) -> void
+
+    def call: (Hash[String, untyped] env) -> rack_response
+
+    private
+
+    def cache_headers: (String etag) -> Hash[String, String]
+
+    def fresh?: (Hash[String, untyped] env, String etag) -> bool
+
+    def etag_for: (untyped spec) -> String
+
+    def error: (untyped req_method, Integer status, String message) -> rack_response
+
+    def fetch: (untyped spec) -> String
+
+    def parse: (untyped path, untyped query) -> Hash[Symbol, untyped]
+
+    def parse_dimensions: (untyped path) -> [ Integer, Integer ]
+
+    def parse_query_string: (untyped query) -> Hash[String, String]
+
+    def parse_color: (untyped value, untyped default) -> Array[Integer]
+  end
+end

data/sig/placeholder_image/renderer.rbs

@@ -0,0 +1,53 @@
+module PlaceholderImage
+  # Generates a placeholder PNG from dimensions, colors, and label text.
+  module Renderer
+    type rgb = Array[Integer]
+
+    LABEL_WIDTH_PCT: Float
+    LABEL_HEIGHT_PCT: Float
+
+    # Minimal 8-bit truecolor PNG encoder.
+    class Canvas
+      SIGNATURE: String
+
+      attr_reader width: Integer
+      attr_reader height: Integer
+
+      @width: Integer
+      @height: Integer
+      @row_bytes: Integer
+      @data: String
+
+      def initialize: (Integer width, Integer height, PlaceholderImage::Renderer::rgb rgb) -> void
+
+      def []=: (Integer x, Integer y, PlaceholderImage::Renderer::rgb rgb) -> void
+
+      def fill_rect: (Integer x, Integer y, Integer width, Integer height, PlaceholderImage::Renderer::rgb rgb) -> void
+
+      def to_png: () -> String
+
+      private
+
+      def chunk: (String type, String data) -> String
+    end
+
+    # 5x7 bitmap font, just enough to render dimension labels such as "1024x768".
+    module Font
+      FONT_WIDTH: Integer
+      FONT_HEIGHT: Integer
+      GLYPHS: Hash[String, Array[String]]
+
+      def self.advance: (Integer scale) -> Integer
+
+      def self.text_width: (String text, Integer scale) -> Integer
+
+      def self.draw: (PlaceholderImage::Renderer::Canvas canvas, String text, Integer x, Integer y, Integer scale, PlaceholderImage::Renderer::rgb color) -> void
+    end
+
+    def self?.call: (width: Integer, height: Integer, bg: PlaceholderImage::Renderer::rgb, fg: PlaceholderImage::Renderer::rgb, text: String) -> String
+
+    def self?.draw_border: (PlaceholderImage::Renderer::Canvas canvas, PlaceholderImage::Renderer::rgb color) -> void
+
+    def self?.draw_label: (PlaceholderImage::Renderer::Canvas canvas, String text, PlaceholderImage::Renderer::rgb color) -> void
+  end
+end

data/sig/placeholder_image/version.rbs

@@ -0,0 +1,3 @@
+module PlaceholderImage
+  VERSION: String
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: placeholder-image
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Rodney Waldhoff
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: A small, dependency-light Rack middleware that generates simple placeholder
+  images.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/placeholder_image.rb
+- lib/placeholder_image/middleware.rb
+- lib/placeholder_image/renderer.rb
+- lib/placeholder_image/version.rb
+- sig/placeholder_image/middleware.rbs
+- sig/placeholder_image/renderer.rbs
+- sig/placeholder_image/version.rbs
+homepage: https://github.com/rodw/placeholder-image-rb
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/rodw/placeholder-image-rb/issues
+  changelog_uri: https://github.com/rodw/placeholder-image-rb/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/placeholder-image
+  homepage_uri: https://github.com/rodw/placeholder-image-rb
+  source_code_uri: https://github.com/rodw/placeholder-image-rb
+  rubygems_mfa_required: 'true'
+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: '5.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: Rack middleware for generating placeholder images
+test_files: []