syrma 0.1.0

data/lib/syrma/script_launcher.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Syrma
+  module ScriptLauncher
+    Launch = Struct.new(:fiber, :status, keyword_init: true)
+
+    module WindowRun
+      def run = Fiber.yield(self)
+    end
+
+    module AppRun
+      def run
+        return super unless Thread.current[:syrma_script_launch]
+
+        Fiber.yield(self)
+      end
+    end
+
+    module_function
+
+    def launch(path, argv: [], backend: :headless, **options)
+      install!
+      Instrumentation.install!
+      opened = []
+      launch = Launch.new
+      launch.fiber = Fiber.new do
+        original_argv = ARGV.dup
+        Thread.current[:syrma_script_launch] = true
+        ARGV.replace(argv)
+        Instrumentation.capture_windows(backend: backend, on_open: lambda { |window|
+          opened << window
+          window.extend(WindowRun)
+        }) { load(File.expand_path(path)) }
+        launch.status = 0
+      rescue SystemExit => error
+        launch.status = error.status
+      ensure
+        ARGV.replace(original_argv)
+        Thread.current[:syrma_script_launch] = nil
+      end
+      launch.fiber.resume
+      raise Error, "Script did not open a window: #{path}" if opened.empty?
+
+      session = Session.new(**options, backend: backend, attached_windows: opened, owns_windows: true)
+      session.launcher = launch
+      session
+    end
+
+    def finish(launch)
+      return unless launch&.fiber&.alive?
+
+      launch.fiber.resume
+    end
+
+    def install!
+      return if @installed
+
+      Zaniah::App.prepend(AppRun)
+      @installed = true
+    end
+  end
+end

data/lib/syrma/session.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Syrma
+  class Session
+    attr_reader :raster, :strict, :timeout, :event_log, :app, :event_frames, :font_paths, :text_mode, :windows, :drivers
+
+    class << self
+      def attach(window, **options) = new(**options, attached_windows: [window], owns_windows: false)
+      def launch_script(path, argv: [], **options) = ScriptLauncher.launch(path, argv: argv, **options)
+
+      def for_app(app, backend: :headless, **options)
+        Instrumentation.install!
+        windows = Instrumentation.capture_windows(backend: backend) { yield(app) }
+        raise Error, "No window was opened inside the block" if windows.empty?
+
+        new(**options, backend: backend, app: app, attached_windows: windows, owns_windows: true)
+      end
+    end
+
+    def initialize(width: 800, height: 600, backend: :headless, text: nil, fonts: nil,
+                   raster: nil, clock: :virtual, strict: nil, timeout: nil, keymap: nil,
+                   app: nil, max_frames: 20, event_frames: nil, attached_windows: nil,
+                   owns_windows: true, **window_options, &mount)
+      config = Syrma.configuration
+      text ||= config.text
+      fonts ||= config.fonts
+      strict = config.strict if strict.nil?
+      timeout ||= ENV["SYRMA_TIMEOUT"] || config.timeout
+      event_frames ||= config.event_frames
+      raster ||= ENV["SYRMA_RASTER"] == "eager" ? :eager : :lazy
+      validate_options!(backend, event_frames, raster, clock)
+      Instrumentation.install!
+
+      @raster = raster
+      @strict = strict
+      @app = app
+      @max_frames = max_frames
+      @clock = clock == :virtual ? Clock.new : (clock == :real ? Zaniah::MONOTONIC_CLOCK : clock)
+      @event_frames = event_frames
+      @timeout = Float(timeout)
+      @event_log = EventLog.new
+      @text_mode = text
+      @owns_windows = owns_windows
+      @backend = backend
+      @text = text
+      @fonts = fonts
+      keymap = VirtualKeymap.new(keymap, @clock) if keymap
+      @outputs = {}
+      @windows = attached_windows || [open_window(backend, width, height, window_options, keymap)]
+      @drivers = @windows.map { |window| prepare(window, backend, text, fonts) }
+      @font_paths = text == :deterministic ? [Internals.bundled_font_path, *fonts.map { |font| File.expand_path(font) }] : []
+      @current = 0
+      mount&.call(window)
+      settle
+    end
+
+    def window(title: nil, index: nil)
+      return @windows[@current] unless title || index
+
+      selected = index ? @windows[index] : @windows.find { |candidate| candidate.title == title }
+      raise Error, "Window not found: #{title ? "title: #{title.inspect}" : "index: #{index}"}" unless selected
+
+      @current = @windows.index(selected)
+      driver
+    end
+
+    def driver = @drivers[@current]
+    def session = self
+    def method_missing(name, ...) = driver.respond_to?(name) ? driver.public_send(name, ...) : super
+    def respond_to_missing?(name, include_all = false) = driver.respond_to?(name, include_all) || super
+
+    def settle
+      @max_frames.times do
+        @app&.executor&.drain
+        sync_app_windows
+        busy = false
+        @windows.each do |candidate|
+          next if candidate.closed? || !candidate.dirty?
+
+          candidate.tick
+          busy = true
+        end
+        return self unless busy || (@app && !Internals.executor_idle?(@app.executor))
+      end
+      raise UnstableUI, "UI did not stabilize within #{@max_frames} frames (continuous animation?)"
+    end
+
+    def advance(seconds)
+      raise Error, "advance is unavailable for this clock" unless @clock.respond_to?(:advance)
+
+      @clock.advance(seconds)
+      @windows.reject(&:closed?).each(&:tick)
+      settle
+    end
+
+    def wait_for(message = "Condition was not met", timeout: @timeout)
+      deadline = Clock.real_now + timeout
+      loop do
+        settle
+        result = yield
+        return result if result
+
+        if Clock.real_now >= deadline
+          detail = message.respond_to?(:call) ? message.call : message
+          raise WaitTimeout, "Timed out after #{timeout} seconds: #{detail}"
+        end
+        sleep 0.01
+      end
+    end
+
+    def screenshot_pixels(target = driver)
+      settle
+      clear = target.window.testing_clear || Zaniah::Platform::Headless::Window::DEFAULT_CLEAR
+      target.window.device.render(target.window.scene, clear: clear)
+    end
+
+    def tui?(target = driver) = @outputs.key?(target.window)
+    def output_for(target = driver) = @outputs.fetch(target.window)
+    def exit_status = @launcher&.status
+
+    def launcher=(launcher)
+      @launcher = launcher
+    end
+
+    def close
+      closed = !@owns_windows || @windows.map { |candidate| candidate.closed? || candidate.close }.all?
+      ScriptLauncher.finish(@launcher) if @launcher
+      closed
+    end
+
+    private
+
+    def validate_options!(backend, event_frames, raster, clock)
+      raise ArgumentError, "backend must be :headless or :tui" unless %i[headless tui].include?(backend)
+      raise ArgumentError, "event_frames must be :each or :gesture" unless %i[each gesture].include?(event_frames)
+      raise ArgumentError, "raster must be :lazy or :eager" unless %i[lazy eager].include?(raster)
+      raise ArgumentError, "clock must be :virtual, :real, or callable" unless %i[virtual real].include?(clock) || clock.respond_to?(:call)
+    end
+
+    def open_window(backend, width, height, options, keymap)
+      options = options.merge(clock: @clock)
+      options[:keymap] = keymap if keymap
+      if backend == :tui
+        output = options[:output] || StringIO.new
+        window = Zaniah::Platform.open_window(backend: backend, width: width, height: height,
+                                              input: options[:input] || StringIO.new, output: output,
+                                              **options.except(:input, :output))
+        @outputs[window] = output
+        window
+      else
+        Zaniah::Platform.open_window(backend: backend, width: width, height: height, **options)
+      end
+    end
+
+    def prepare(candidate, backend, text, fonts)
+      actual_backend = candidate.is_a?(Zaniah::Platform::TUI::Window) ? :tui : backend
+      candidate.text_system = TextSystems.build(text, fonts: fonts) unless actual_backend == :tui
+      WindowDriver.new(candidate, self)
+    end
+
+    def sync_app_windows
+      return unless @app
+
+      (@app.windows - @windows).each do |candidate|
+        @windows << candidate
+        @drivers << prepare(candidate, @backend, @text, @fonts)
+      end
+    end
+  end
+end

data/lib/syrma/snapshot.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Syrma
+  Node = Data.define(:path, :element, :type, :test_id, :key, :text, :color, :font_size,
+                     :bounds, :visible_bounds, :background, :border_color, :radius,
+                     :handlers, :tooltip, :children) do
+    def visible? = visible_bounds.width.positive? && visible_bounds.height.positive?
+    def clickable? = handlers.include?(:click) || handlers.include?(:mouse_down)
+    def center = Zaniah::Point.new(visible_bounds.x + visible_bounds.width / 2.0,
+                                   visible_bounds.y + visible_bounds.height / 2.0)
+    def descendants = children.flat_map { |child| [child, *child.descendants] }
+    def content_text = [text, *descendants.map(&:text)].compact.join(" ")
+    def ancestor_of?(other) = other.path.length > path.length && other.path.first(path.length) == path
+    def inspect = "#<#{type}#{test_id && " @#{test_id}"}#{text && " #{text.inspect}"} #{path.join('.')}>"
+  end
+
+  Tree = Data.define(:frame, :size, :root, :nodes, :hits, :text_runs, :menu, :menu_index, :tooltip) do
+    def hit_at(point, event: :mouse_down, button: :left)
+      hits.reverse_each do |bounds, node|
+        next unless bounds.contains?(point)
+
+        return node if node.nil? || Tree.handles?(node, event, button)
+      end
+      nil
+    end
+
+    def self.handles?(node, event, button)
+      case event
+      when :mouse_down
+        (button == :right && Internals.context_menu(node.element)) ||
+          (node.handlers & %i[mouse_down click drag]).any?
+      when :mouse_move then node.handlers.include?(:hover) || node.tooltip
+      when :mouse_up then node.handlers.include?(:mouse_up)
+      when :scroll then node.handlers.include?(:scroll_wheel)
+      end
+    end
+  end
+
+  class SnapshotBuilder
+    def build(window)
+      by_element = {}.compare_by_identity
+      nodes = []
+      viewport = Zaniah::Bounds.new(0, 0, window.content_size.width, window.content_size.height)
+      root = window.testing_root && visit(window.testing_root, viewport, [0], nodes, by_element)
+      hits = window.dispatcher.hits.map { |hit| [hit.bounds, hit.owner && by_element[hit.owner]] }
+      popup = window.popup
+      Tree.new(frame: window.testing_frame, size: window.content_size, root: root,
+               nodes: nodes.freeze, hits: hits.freeze, text_runs: window.text_runs.map(&:dup).freeze,
+               menu: popup&.labels, menu_index: popup&.selected_index,
+               tooltip: Internals.shown_tooltip(window))
+    end
+
+    private
+
+    def visit(element, clip, path, nodes, by_element)
+      bounds = element.layout_node&.bounds or return nil
+      style = Internals.style(element)
+      return nil if style[:display] == :none
+
+      visible = bounds.intersect(clip)
+      child_clip = style[:overflow] == :visible ? clip : visible
+      index = nodes.length
+      nodes << nil
+      children = element.children.each_with_index.filter_map do |child, child_index|
+        visit(child, child_clip, path + [child_index], nodes, by_element)
+      end
+      node = Node.new(
+        path: path.freeze, element: element, type: element.class.name.split("::").last.downcase.to_sym,
+        test_id: element.test_id, key: Internals.key(element),
+        text: text_attr(element, :text), color: text_attr(element, :text_color),
+        font_size: text_attr(element, :font_size), bounds: bounds, visible_bounds: visible,
+        background: Internals.background(element), border_color: Internals.border_color(element),
+        radius: Internals.radius(element), handlers: element.handlers,
+        tooltip: Internals.tooltip(element), children: children.freeze
+      )
+      nodes[index] = node
+      by_element[element] = node
+    end
+
+    def text_attr(element, name) = element.is_a?(Zaniah::Text) ? element.public_send(name) : nil
+  end
+end

data/lib/syrma/snapshots/store.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+
+module Syrma
+  module Snapshots
+    class Store
+      NAME = /\A[A-Za-z0-9_-]+\z/
+
+      attr_reader :root
+
+      def initialize(root: nil, env: ENV)
+        @root = File.expand_path(root || env["SYRMA_SNAPSHOT_DIR"] || Syrma.configuration.snapshot_dir)
+        @env = env
+      end
+
+      def update? = @env["SYRMA_UPDATE_SNAPSHOTS"] == "1"
+      def ci? = !@env["CI"].to_s.empty?
+
+      def path(test_file:, test_class:, name:, ext:)
+        unless name.to_s.match?(NAME)
+          raise ArgumentError, "Snapshot names may contain only letters, digits, hyphens, and underscores: #{name.inspect}"
+        end
+
+        dir = File.join(root, File.basename(test_file.to_s, ".rb"), test_class.to_s.gsub(/[^A-Za-z0-9_-]/, "_"))
+        File.join(dir, "#{name}.#{ext}").tap do |full|
+          raise ArgumentError, "Snapshot path is outside the configured directory" unless full.start_with?(root + File::SEPARATOR)
+
+          record(full)
+        end
+      end
+
+      def write(path, bytes)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.binwrite(path, bytes)
+      end
+
+      def usage_path
+        File.join(ENV["SYRMA_ARTIFACTS"] || Syrma.configuration.artifacts_dir, "used-snapshots.txt")
+      end
+
+      def reset_usage!(full: false)
+        FileUtils.mkdir_p(File.dirname(usage_path))
+        File.write(usage_path, full ? "# full\n" : "# partial\n", encoding: "UTF-8")
+      end
+
+      def unused
+        return [] unless File.exist?(usage_path)
+
+        lines = File.readlines(usage_path, chomp: true, encoding: "UTF-8")
+        raise Error, "Cannot prune snapshots after a partial test run" unless lines.first == "# full"
+
+        used = lines.drop(1).to_h { |path| [File.expand_path(path), true] }
+        Dir[File.join(root, "**", "*")].select { |path| File.file?(path) && !used[File.expand_path(path)] }
+      end
+
+      private
+
+      def record(path)
+        FileUtils.mkdir_p(File.dirname(usage_path))
+        paths = [path]
+        paths << path.sub(/\.png\z/, ".meta.json") if path.end_with?(".png")
+        File.open(usage_path, "a", encoding: "UTF-8") { |file| paths.each { |used| file.puts(used) } }
+      end
+    end
+  end
+
+  module Visual
+    module_function
+
+    def meta(session)
+      window = session.window
+      text = window.text_system
+      {
+        zaniah: Zaniah::VERSION,
+        size: [window.content_size.width, window.content_size.height],
+        scale_factor: window.scale_factor,
+        text: text&.class&.name,
+        fonts: session.font_paths.map { |path| Digest::SHA256.file(path).hexdigest[0, 16] }
+      }
+    end
+
+    def check_screenshot(session, store:, path:, threshold: 2, max_diff_pixels: 0,
+                         max_diff_ratio: nil, region: nil, mask: [], artifacts: nil)
+      validate_limits!(max_diff_pixels, max_diff_ratio)
+      width = session.window.content_size.width.to_i
+      height = session.window.content_size.height.to_i
+      actual = session.screenshot_pixels.dup
+      Array(mask).each { |target| Image.mask!(actual, width, height, bounds_for(target)) }
+      width, height, actual = Image.crop(actual, width, height, bounds_for(region)) if region
+      png = Zaniah::PNG.encode(width, height, actual)
+      meta_path = path.sub(/\.png\z/, ".meta.json")
+
+      unless File.exist?(path)
+        if store.ci? && !store.update?
+          raise SnapshotMissing, "Snapshot not found: #{path} (set SYRMA_UPDATE_SNAPSHOTS=1 to create it)"
+        end
+        write_golden(store, path, meta_path, png, session)
+        return :created
+      end
+
+      expected_width, expected_height, expected = Zaniah::PNG.decode(File.binread(path))
+      result = if [expected_width, expected_height] == [width, height]
+                 Comparator.new(threshold: threshold).compare(width, height, expected, actual)
+               end
+      valid = result && result.diff_pixels <= max_diff_pixels &&
+              (max_diff_ratio.nil? || result.ratio <= max_diff_ratio)
+      return :matched if valid
+
+      if store.update?
+        write_golden(store, path, meta_path, png, session)
+        return :updated
+      end
+
+      write_diff_artifacts(artifacts, path, png, width, height, result) if artifacts
+      old_meta = File.exist?(meta_path) ? JSON.parse(File.read(meta_path, encoding: "UTF-8")) : {}
+      font_hint = old_meta["fonts"] && old_meta["fonts"] != meta(session)[:fonts] ? "\n  Font configuration differs from the snapshot" : ""
+      detail = if result
+                 "#{result.diff_pixels} differing pixels (#{(result.ratio * 100).round(3)}%)"
+               else
+                 "size mismatch: expected #{expected_width}x#{expected_height}, got #{width}x#{height}"
+               end
+      raise SnapshotMismatch, "Image snapshot mismatch: #{File.basename(path)} #{detail}#{font_hint}" +
+                              (artifacts ? "\n  Artifacts: #{artifacts}" : "")
+    end
+
+    def bounds_for(target)
+      node = target.is_a?(Locator) ? target.resolve : target
+      node.respond_to?(:bounds) ? node.bounds : node
+    end
+
+    def validate_limits!(pixels, ratio)
+      raise ArgumentError, "max_diff_pixels must be a non-negative integer" unless pixels.is_a?(Integer) && pixels >= 0
+      return if ratio.nil? || (ratio.is_a?(Numeric) && ratio.between?(0, 1))
+
+      raise ArgumentError, "max_diff_ratio must be between 0.0 and 1.0"
+    end
+
+    def write_golden(store, path, meta_path, png, session)
+      store.write(path, png)
+      store.write(meta_path, JSON.pretty_generate(meta(session)))
+    end
+
+    def write_diff_artifacts(dir, expected_path, actual_png, width, height, result)
+      FileUtils.mkdir_p(dir)
+      File.binwrite(File.join(dir, "expected.png"), File.binread(expected_path))
+      File.binwrite(File.join(dir, "actual.png"), actual_png)
+      Zaniah::PNG.write(File.join(dir, "diff.png"), width, height, result.diff_image) if result
+    end
+  end
+end

data/lib/syrma/snapshots/terminal_format.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Syrma
+  module TerminalFormat
+    ROW = 20
+    COL = 8
+    ANSI = /\e\[[0-9;?]*[A-Za-z]/
+    RGB = /\e\[38;2;(\d+);(\d+);(\d+)m/
+
+    module_function
+
+    def lines(output, colors: false)
+      frame = output.split("\e[H").last.to_s
+      frame = frame.gsub(RGB) { format("{#%02x%02x%02x}", $1.to_i, $2.to_i, $3.to_i) } if colors
+      frame.gsub(ANSI, "").split("\r\n").map(&:rstrip)
+    end
+
+    def overlaps(text_runs)
+      cells = text_runs.map do |x, y, text, _color|
+        column = (x / COL).floor
+        [(y / ROW).floor, column, column + Zaniah::Unicode.width(text.to_s), text]
+      end
+      cells.combination(2).filter_map do |first, second|
+        [first[3], second[3], first[0]] if first[0] == second[0] && first[1] < second[2] && second[1] < first[2]
+      end
+    end
+  end
+end

data/lib/syrma/snapshots/tree_format.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Syrma
+  module TreeFormat
+    DEFAULT = %i[test_id text bounds bg handlers tooltip].freeze
+
+    module_function
+
+    def dump(node, attributes: DEFAULT, depth: 0, out: +"")
+      parts = [node.type.to_s]
+      parts << "@#{node.test_id}" if attributes.include?(:test_id) && node.test_id
+      parts << node.text.inspect if attributes.include?(:text) && node.text
+      if attributes.include?(:bounds)
+        bounds = node.bounds
+        parts << "[#{num(bounds.x)},#{num(bounds.y)} #{num(bounds.width)}x#{num(bounds.height)}]"
+      end
+      parts << "bg=#{node.background}" if attributes.include?(:bg) && node.background && node.background != "#0000"
+      parts << "on=#{node.handlers.join(',')}" if attributes.include?(:handlers) && node.handlers.any?
+      parts << "tooltip=#{node.tooltip.inspect}" if attributes.include?(:tooltip) && node.tooltip
+      out << ("  " * depth) << parts.join(" ") << "\n"
+      node.children.each { |child| dump(child, attributes: attributes, depth: depth + 1, out: out) }
+      out
+    end
+
+    def num(value)
+      rounded = value.to_f.round(2)
+      rounded == rounded.to_i ? rounded.to_i.to_s : rounded.to_s
+    end
+  end
+end

data/lib/syrma/text_systems.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Syrma
+  module TextSystems
+    module_function
+
+    def build(mode, fonts: [])
+      case mode
+      when :none, nil then nil
+      when :native then Zaniah::TextSystem::Renderer.new
+      when :deterministic
+        paths = [Internals.bundled_font_path, *fonts.map { |font| File.expand_path(font) }]
+        missing = paths.reject { |path| File.file?(path) }
+        raise ArgumentError, "Fonts not found: #{missing.join(', ')}" unless missing.empty?
+
+        db = Zaniah::TextSystem::FontDB.new(paths: paths)
+        primary = fonts.empty? ? paths.first : paths[1]
+        Zaniah::TextSystem::Renderer.new(font: db.open(primary), font_db: db)
+      else
+        raise ArgumentError, "Unsupported text mode: #{mode.inspect}" unless mode.respond_to?(:layout_line)
+
+        mode
+      end
+    end
+  end
+end

data/lib/syrma/version.rb

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

data/lib/syrma/visual/comparator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Syrma
+  class Comparator
+    Result = Data.define(:width, :height, :diff_pixels, :diff_image) do
+      def ratio = diff_pixels.fdiv(width * height)
+    end
+
+    def initialize(threshold: 0)
+      raise ArgumentError, "threshold must be between 0 and 255" unless threshold.is_a?(Numeric) && threshold.between?(0, 255)
+
+      @threshold = threshold
+    end
+
+    def compare(width, height, expected, actual)
+      expected_size = width * height * 4
+      unless expected.bytesize == actual.bytesize && expected.bytesize == expected_size
+        raise ArgumentError, "Image dimensions do not match"
+      end
+
+      diff = String.new(capacity: expected_size, encoding: Encoding::BINARY)
+      count = 0
+      expected_bytes = expected.unpack("C*")
+      actual_bytes = actual.unpack("C*")
+      (width * height).times do |index|
+        offset = index * 4
+        different = 4.times.any? { |channel| (expected_bytes[offset + channel] - actual_bytes[offset + channel]).abs > @threshold }
+        if different
+          count += 1
+          diff << [255, 0, 0, 255].pack("C4")
+        else
+          gray = ((expected_bytes[offset] * 30 + expected_bytes[offset + 1] * 59 + expected_bytes[offset + 2] * 11) / 300 + 170).clamp(0, 255)
+          diff << [gray, gray, gray, 255].pack("C4")
+        end
+      end
+      Result.new(width: width, height: height, diff_pixels: count, diff_image: diff)
+    end
+  end
+end

data/lib/syrma/visual/image.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Syrma
+  module Visual
+    module Image
+      module_function
+
+      def crop(rgba, width, height, bounds)
+        x = bounds.x.floor.clamp(0, width)
+        y = bounds.y.floor.clamp(0, height)
+        cropped_width = bounds.right.ceil.clamp(0, width) - x
+        cropped_height = bounds.bottom.ceil.clamp(0, height) - y
+        out = String.new(capacity: cropped_width * cropped_height * 4, encoding: Encoding::BINARY)
+        cropped_height.times do |row|
+          out << rgba.byteslice(((y + row) * width + x) * 4, cropped_width * 4)
+        end
+        [cropped_width, cropped_height, out]
+      end
+
+      def mask!(rgba, width, height, bounds, color: [255, 0, 255, 255])
+        pixel = color.pack("C4")
+        (bounds.y.floor.clamp(0, height)...bounds.bottom.ceil.clamp(0, height)).each do |row|
+          (bounds.x.floor.clamp(0, width)...bounds.right.ceil.clamp(0, width)).each do |column|
+            rgba[(row * width + column) * 4, 4] = pixel
+          end
+        end
+        rgba
+      end
+    end
+  end
+end