inlay 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c4e3fe710798287aba2920de80b5a321c2d89543256b9b6079eba08d93dc9e3
+  data.tar.gz: 1f3f0803affda38c5dc7c8c821f2cfdbe7d18846a184e317712a0477a3f2a9e7
+SHA512:
+  metadata.gz: 926cf085ff8b9dcad417763adf7da3d8de669a134df5e5c218dacf42c4a242091a54693e81672dd33e38ef598c31fdffd679e45711c5c92e9341a094a8cab3fa
+  data.tar.gz: 8272ef2ad9566553b4562107c74617d09d22680d6c672897168d7521dd6779387a425cb1b051986fa63ddd961e4dd0137a589db2a067291b6eeb7a66abdae7c8

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2026-09-25
+
+Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+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,67 @@
+# Inlay
+
+Render Ruby graphics where you inspect them. Inlay shows Tessel images, RBGL surfaces, and chart output in terminals, IRB, and Pry.
+
+## Install
+
+```sh
+gem install inlay
+```
+
+Add `inlay` to your Gemfile. Inlay uses [Tessel](https://github.com/rbgfx/tessel) for images and [Termvas](https://github.com/rbgfx/termvas) for terminal output.
+
+## Use in IRB
+
+Add this to `~/.irbrc`:
+
+```ruby
+require "inlay/irb"
+```
+
+Now returning an image from a prompt displays it inline and leaves a short summary as the result:
+
+```ruby
+image = Tessel.read("brick.png").scale_nearest(64, 64)
+image
+```
+
+Pry uses the same integration style:
+
+```ruby
+require "inlay/pry"
+```
+
+Inlay uses the terminal protocol selected by Termvas: Kitty, iTerm2, Sixel, or true-color half blocks. Piped output, `TERM=dumb`, `INLAY=off`, and `NO_COLOR` with half blocks show only the summary.
+
+## Use in a script
+
+```ruby
+require "inlay"
+
+image = Tessel.read("brick.png")
+Inlay.show(image, width: 40)
+Inlay.config.max_rows = 30
+```
+
+To install the short `inlay(value)` helper, require `inlay/kernel`. Explicit calls accept image paths; ordinary returned strings are never treated as paths.
+
+Objects can implement `to_inlay` and return a `Tessel::Image`, `{ png: bytes }`, `{ svg: markup, png: -> { bytes } }`, or `{ frames: images, fps: number }`. Custom object types can also be registered:
+
+```ruby
+Inlay.register(MySurface) { |surface| surface.to_tessel_image }
+```
+
+## Configuration
+
+`Inlay.config.enabled` toggles terminal rendering. `max_rows` caps terminal height and `max_pixels` limits decoded and displayed input size. Small images (up to 32×32) are enlarged with nearest-neighbor scaling; larger images are reduced with alpha-aware area averaging. Set `INLAY=off` to disable terminal output for a process.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake verify
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task verify: :spec
+task default: :verify

data/docs/spikes.md

@@ -0,0 +1,8 @@
+# Integration spikes
+
+- IRB 1.18's `IRB::Inspector` supports a streaming inspector that writes into IRB's result buffer. Inlay writes terminal escapes to `$stdout` separately and leaves a short summary in the buffer. IRB paging and assignment truncation therefore only see the summary. The supported minimum is IRB 1.13, the first version with the supported inspector API.
+- `.irbrc` runs before the first prompt, so environment-based terminal detection can be cached at install time without competing with Reline input. Inlay does not issue device queries.
+- Rails console uses IRB's configured inspector when initialized after `.irbrc`; re-running `Inlay.irb_install!` wraps a subsequently selected inspector. Rails itself is not part of the test dependency set.
+- Pry's configured printer receives `(output, value, pry_instance)`; the adapter retains that printer and passes it the summary.
+- IRuby's public display registry supports predicate matchers and dynamic MIME pairs. SVG is preferred; PNG and GIF-in-HTML are selected from the normalized return value.
+- `@ruby/3.4-wasm-wasi` 2.10.1 / Ruby 3.4.1 with Larb and JS host bindings completed 3,600 simulated 60 fps callbacks in 61.95 seconds. With one stable JS trampoline and Ruby/JS GC every 600 frames, WASM memory changed from 71,499,776 to 71,565,312 bytes; JS heap grew 4,261,280 bytes. This validates the callback strategy under Node, not a browser or GPU workload.

data/lib/inlay/adapters.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Inlay
+  module Adapters
+    @adapters = {}
+
+    module_function
+
+    def register(klass, adapter)
+      raise TypeError, "adapter key must be a Class or Module" unless klass.is_a?(Module)
+
+      @adapters[klass] = adapter
+    end
+
+    def convert(object)
+      pair = @adapters.find { |klass, _| object.is_a?(klass) }
+      return pair.last.call(object) if pair
+
+      return object if defined?(Tessel::Image) && object.is_a?(Tessel::Image)
+
+      if defined?(RBGL::Engine::Framebuffer) && object.is_a?(RBGL::Engine::Framebuffer)
+        return Tessel::Image.from_rgba(object.width, object.height, object.to_rgba_bytes)
+      end
+
+      if defined?(RBGL::Engine::Texture) && object.is_a?(RBGL::Engine::Texture)
+        bytes = object.data.flat_map { |color| [color.r, color.g, color.b, color.a] }.pack("C*")
+        return Tessel::Image.from_rgba(object.width, object.height, bytes)
+      end
+
+      if defined?(Inkplot::Chart) && object.is_a?(Inkplot::Chart)
+        return object.to_inlay
+      end
+
+      nil
+    end
+  end
+end

data/lib/inlay/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Inlay
+  class Config
+    attr_accessor :enabled
+    attr_reader :max_rows, :max_pixels
+
+    def initialize
+      @enabled = true
+      @max_rows = 24
+      @max_pixels = 1_048_576
+    end
+
+    def max_rows=(value)
+      @max_rows = positive_integer(value, :max_rows)
+    end
+
+    def max_pixels=(value)
+      @max_pixels = positive_integer(value, :max_pixels)
+    end
+
+    private
+
+    def positive_integer(value, name)
+      number = Integer(value)
+      raise ArgumentError, "#{name} must be positive" unless number.positive?
+
+      number
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "#{name} must be a positive integer"
+    end
+  end
+end

data/lib/inlay/irb.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "inlay"
+require "irb"
+require "irb/inspector"
+
+module Inlay
+  module IRBIntegration
+    class << self
+      attr_reader :original, :wrapper
+
+      def install
+        mode = IRB.conf[:INSPECT_MODE]
+        selected = mode.is_a?(IRB::Inspector) ? mode : IRB::Inspector::INSPECTORS[mode] || IRB::Inspector::INSPECTORS[mode.to_s] || IRB::Inspector::INSPECTORS[:p]
+        return false unless selected
+
+        @original = selected unless mode.equal?(@wrapper)
+        @protocol = TerminalOutput.protocol
+        @wrapper = IRB::Inspector.new(proc do |value, output, colorize: true|
+          begin
+            if Inlay.displayable?(value)
+              output << Inlay.show(value, protocol: @protocol)
+            else
+              @original.inspect_value(value, output, colorize: colorize)
+            end
+          rescue StandardError
+            @original.inspect_value(value, output, colorize: colorize)
+          end
+        end)
+        IRB.conf[:INSPECT_MODE] = @wrapper
+        context = IRB.CurrentContext if IRB.respond_to?(:CurrentContext)
+        context.inspect_mode = @wrapper if context&.respond_to?(:inspect_mode=)
+        true
+      end
+
+      def uninstall
+        return false unless @wrapper && IRB.conf[:INSPECT_MODE].equal?(@wrapper)
+
+        IRB.conf[:INSPECT_MODE] = @original
+        context = IRB.CurrentContext if IRB.respond_to?(:CurrentContext)
+        context.inspect_mode = @original if context&.respond_to?(:inspect_mode=)
+        @wrapper = @original = @protocol = nil
+        true
+      end
+    end
+  end
+end
+
+Inlay::IRBIntegration.install

data/lib/inlay/kernel.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "inlay"
+
+module Kernel
+  private
+
+  def inlay(object, **options)
+    Inlay.show(object, **options)
+  end
+end

data/lib/inlay/normalizer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Inlay
+  Normalized = Struct.new(:image, :svg, :png, :frames, :fps, keyword_init: true)
+
+  module Normalizer
+    module_function
+
+    def call(object, allow_path: false, seen: {})
+      raise Error, "recursive to_inlay result" if seen[object.object_id]
+
+      converted = Adapters.convert(object)
+      return Normalized.new(image: converted) if converted.is_a?(Tessel::Image)
+      return from_value(converted, allow_path: allow_path, seen: seen) unless converted.nil?
+
+      return from_value(object.to_inlay, allow_path: allow_path, seen: seen.merge(object.object_id => true)) if object.respond_to?(:to_inlay)
+      return from_value(object, allow_path: allow_path, seen: seen) if object.is_a?(Hash)
+      return from_path(object) if allow_path && path_value?(object)
+
+      Normalized.new
+    end
+
+    def terminal_image(normalized)
+      return normalized.image if normalized.image
+      return Tessel.decode(normalized.png, max_pixels: Inlay.config.max_pixels) if normalized.png.is_a?(String)
+      if normalized.png.respond_to?(:call)
+        value = normalized.png.call
+        return value if value.is_a?(Tessel::Image)
+        return Tessel.decode(value, max_pixels: Inlay.config.max_pixels) if value.is_a?(String)
+        return call(value).image
+      end
+      return call(normalized.frames.first).image if normalized.frames&.any?
+
+      nil
+    end
+
+    def from_value(value, allow_path:, seen:)
+      raise Error, "recursive to_inlay result" if seen[value.object_id]
+      return Normalized.new(image: value) if value.is_a?(Tessel::Image)
+      return from_path(value) if allow_path && path_value?(value)
+      return Normalized.new unless value.is_a?(Hash)
+
+      data = value.each_with_object({}) { |(key, item), result| result[key.to_sym] = item if key.respond_to?(:to_sym) }
+      if data[:frames]
+        frames = Array(data[:frames])
+        raise ArgumentError, "frames must not be empty" if frames.empty?
+        raise TypeError, "frames must contain Tessel::Image values" unless frames.all? { |frame| frame.is_a?(Tessel::Image) }
+        raise TypeError, "fps must be a positive number" unless data[:fps].is_a?(Numeric) && data[:fps].positive?
+
+        return Normalized.new(frames: frames, fps: data[:fps])
+      end
+      raise TypeError, "png must be bytes or a callable" if data[:png] && !data[:png].is_a?(String) && !data[:png].respond_to?(:call)
+      raise TypeError, "svg must be a String" if data[:svg] && !data[:svg].is_a?(String)
+
+      Normalized.new(svg: data[:svg], png: data[:png])
+    end
+    private_class_method :from_value
+
+    def from_path(value)
+      bytes = value.is_a?(Pathname) ? File.binread(value) : String(value)
+      Normalized.new(image: Tessel.decode(bytes, max_pixels: Inlay.config.max_pixels))
+    end
+    private_class_method :from_path
+
+    def path_value?(value)
+      value.is_a?(Pathname) || (value.is_a?(String) && IMAGE_EXTENSIONS.include?(File.extname(value).downcase) && File.file?(value))
+    end
+    IMAGE_EXTENSIONS = %w[.png .ppm .pnm .bmp].freeze
+    private_class_method :path_value?
+  end
+end

data/lib/inlay/pry.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "inlay"
+require "pry"
+
+module Inlay
+  module PryIntegration
+    class << self
+      attr_reader :original, :wrapper
+
+      def install
+        return true if Pry.config.print.equal?(@wrapper)
+
+        @original = Pry.config.print
+        @wrapper = proc do |output, value, pry_instance|
+          begin
+            value = Inlay.show(value) if Inlay.displayable?(value)
+          rescue StandardError
+            # Preserve Pry's configured printer if image rendering fails.
+          end
+          @original.call(output, value, pry_instance)
+        end
+        Pry.config.print = @wrapper
+        true
+      end
+
+      def uninstall
+        return false unless @wrapper && Pry.config.print.equal?(@wrapper)
+
+        Pry.config.print = @original
+        @wrapper = @original = nil
+        true
+      end
+    end
+  end
+end
+
+Inlay::PryIntegration.install

data/lib/inlay/sizer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Inlay
+  module Sizer
+    module_function
+
+    def fit(image, width: nil, height: nil, scale: :auto, columns: nil, rows: nil)
+      raise TypeError, "expected a Tessel::Image" unless image.is_a?(Tessel::Image)
+      raise ArgumentError, "unknown scale mode: #{scale}" unless %i[auto fit pixel none].include?(scale)
+      return image if image.width.zero? || image.height.zero?
+
+      columns ||= width || Termvas::Terminal.new(alt_screen: false).size[0]
+      width = [Integer(width || columns), Integer(columns)].min
+      height = [Integer(height || Inlay.config.max_rows * 2), Inlay.config.max_rows * 2].min
+      raise ArgumentError, "display dimensions must be positive" unless width.positive? && height.positive?
+      pixel_scale = scale == :pixel || (scale == :auto && image.width <= 32 && image.height <= 32)
+      max_factor = [width / [image.width, 1].max, height / [image.height, 1].max].min
+      if pixel_scale && max_factor > 1
+        return image.scale_nearest(image.width * max_factor, image.height * max_factor)
+      end
+      return image if image.width <= width && image.height <= height
+
+      factor = [width.to_f / image.width, height.to_f / image.height, 1.0].min
+      resize_area(image, [(image.width * factor).floor, 1].max, [(image.height * factor).floor, 1].max)
+    end
+
+    def resize_area(image, width, height)
+      bytes = image.bytes
+      output = String.new(capacity: width * height * 4, encoding: Encoding::BINARY)
+      height.times do |y|
+        top = y * image.height.to_f / height
+        bottom = (y + 1) * image.height.to_f / height
+        width.times do |x|
+          left = x * image.width.to_f / width
+          right = (x + 1) * image.width.to_f / width
+          alpha = red = green = blue = area = 0.0
+          (top.floor...bottom.ceil).each do |source_y|
+            weight_y = [bottom, source_y + 1].min - [top, source_y].max
+            (left.floor...right.ceil).each do |source_x|
+              weight = weight_y * ([right, source_x + 1].min - [left, source_x].max)
+              offset = (source_y * image.width + source_x) * 4
+              a = bytes.getbyte(offset + 3)
+              area += weight
+              alpha += a * weight
+              red += bytes.getbyte(offset) * a * weight
+              green += bytes.getbyte(offset + 1) * a * weight
+              blue += bytes.getbyte(offset + 2) * a * weight
+            end
+          end
+          output << (alpha.zero? ? 0 : (red / alpha).round)
+          output << (alpha.zero? ? 0 : (green / alpha).round)
+          output << (alpha.zero? ? 0 : (blue / alpha).round)
+          output << (alpha / area).round
+        end
+      end
+      Tessel::Image.from_rgba(width, height, output)
+    end
+    private_class_method :resize_area
+  end
+end

data/lib/inlay/summary.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Inlay
+  module Summary
+    module_function
+
+    def call(object, normalized)
+      image = normalized.image || (normalized.frames&.first if normalized.frames)
+      dimensions = image ? " #{image.width}x#{image.height}" : ""
+      name = case object
+      when Tessel::Image then "Tessel::Image"
+      else object.class.name || object.class.to_s
+      end
+      frames = normalized.frames ? " frames=#{normalized.frames.length}" : ""
+      "#<#{name}#{dimensions}#{frames}>"
+    end
+  end
+end

data/lib/inlay/terminal_output.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Inlay
+  module TerminalOutput
+    module_function
+
+    def protocol(output: $stdout, env: ENV)
+      return :none unless Inlay.config.enabled
+      return :none unless output.tty?
+      return :none unless env["INLAY"] != "off"
+      return :none if env["TERM"] == "dumb"
+
+      selected = Termvas::Detector.protocol(env)
+      return :none if selected == :blocks && env.key?("NO_COLOR")
+
+      selected
+    end
+
+    def write(image, width: nil, height: nil, scale: :auto, protocol: nil, output: $stdout, env: ENV)
+      selected = (protocol || self.protocol(output: output, env: env)).to_sym
+      return false unless Inlay.config.enabled && output.tty? && selected != :none
+      return false if selected == :blocks && env.key?("NO_COLOR")
+      return false if image.width * image.height > Inlay.config.max_pixels
+
+      image = Sizer.fit(image, width: width, height: height, scale: scale)
+      bytes = image.bytes
+      encoded = case selected.to_sym
+      when :blocks then Termvas::Encoders::Blocks.encode(bytes, image.width, image.height)
+      when :kitty then Termvas::Encoders::Kitty.encode(bytes, image.width, image.height, id: next_kitty_id)
+      when :iterm2
+        png = Tessel::PNG.encode(image)
+        Termvas::Encoders::ITerm2.encode(png, width: image.width, height: image.height)
+      when :sixel then Termvas::Encoders::Sixel.encode(bytes, image.width, image.height)
+      else return false
+      end
+      output.write(encoded)
+      output.write("\n")
+      true
+    end
+
+    def next_kitty_id
+      @kitty_id_lock ||= Mutex.new
+      @kitty_id_lock.synchronize { @kitty_id = (@kitty_id.to_i % 2_147_483_647) + 1 }
+    end
+    private_class_method :next_kitty_id
+  end
+end

data/lib/inlay/version.rb

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

data/lib/inlay.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "tessel"
+require "termvas"
+require "pathname"
+require_relative "inlay/version"
+require_relative "inlay/config"
+require_relative "inlay/adapters"
+require_relative "inlay/normalizer"
+require_relative "inlay/sizer"
+require_relative "inlay/summary"
+require_relative "inlay/terminal_output"
+
+module Inlay
+  class Error < StandardError; end
+
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def register(klass, &adapter)
+      raise ArgumentError, "an adapter block is required" unless adapter
+
+      Adapters.register(klass, adapter)
+    end
+
+    def normalize(object, allow_path: false)
+      Normalizer.call(object, allow_path: allow_path)
+    end
+
+    def displayable?(object)
+      normalized = normalize(object)
+      !!(normalized.image || normalized.svg || normalized.png || normalized.frames)
+    rescue StandardError
+      false
+    end
+
+    def protocol
+      TerminalOutput.protocol
+    end
+
+    def irb_install!
+      require_relative "inlay/irb"
+      IRBIntegration.install
+    end
+
+    def irb_uninstall!
+      IRBIntegration.uninstall if defined?(IRBIntegration)
+    end
+
+    def show(object, width: nil, height: nil, scale: :auto, protocol: nil)
+      normalized = normalize(object, allow_path: true)
+      image = Normalizer.terminal_image(normalized)
+      normalized.image ||= image
+      summary = Summary.call(object, normalized)
+      return summary unless image && TerminalOutput.write(image, width: width, height: height, scale: scale, protocol: protocol)
+
+      summary
+    end
+  end
+end

data/sig/inlay.rbs

@@ -0,0 +1,32 @@
+module Inlay
+  class Error < StandardError
+  end
+
+  class Config
+    attr_accessor enabled: bool
+    attr_accessor max_rows: Integer
+    attr_accessor max_pixels: Integer
+  end
+
+  class Normalized
+    attr_accessor image: untyped
+    attr_accessor svg: String?
+    attr_accessor png: untyped
+    attr_accessor frames: Array[untyped]?
+    attr_accessor fps: Numeric?
+  end
+
+  def self.config: () -> Config
+  def self.register: (Module klass) { (untyped object) -> untyped } -> Module
+  def self.normalize: (untyped object, ?allow_path: bool) -> Normalized
+  def self.displayable?: (untyped object) -> bool
+  def self.protocol: () -> Symbol
+  def self.show: (untyped object, ?width: Integer?, ?height: Integer?, ?scale: Symbol, ?protocol: Symbol?) -> String
+  def self.irb_install!: () -> bool
+  def self.irb_uninstall!: () -> (bool | nil)
+end
+
+module Kernel
+  private
+  def inlay: (untyped object, **untyped options) -> String
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: inlay
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tessel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: termvas
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Render Tessel images and graphics buffers in terminals, IRB, and Pry.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- docs/spikes.md
+- lib/inlay.rb
+- lib/inlay/adapters.rb
+- lib/inlay/config.rb
+- lib/inlay/irb.rb
+- lib/inlay/kernel.rb
+- lib/inlay/normalizer.rb
+- lib/inlay/pry.rb
+- lib/inlay/sizer.rb
+- lib/inlay/summary.rb
+- lib/inlay/terminal_output.rb
+- lib/inlay/version.rb
+- sig/inlay.rbs
+homepage: https://github.com/rbgfx/inlay
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rbgfx/inlay
+  source_code_uri: https://github.com/rbgfx/inlay/tree/main
+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: 4.0.16
+specification_version: 4
+summary: Display Ruby graphics in terminals and REPLs
+test_files: []