proofsheet 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dfb63ef244e4dc5bd439965363d028bb5760f1d76cd4b04b9595278e85990cd5
+  data.tar.gz: '0699294e136dc91a4afa0b718b6ddf07626261c9cc6bcb6cdb756e3563679fdb'
+SHA512:
+  metadata.gz: '0387c6a7d3fe71a573e937f0df9103c26646218f6f5f1283c7ab78fc72b4b3ec6b26d0361156c6280f9d95355ee21c8321dac89d33f3459ed4435f9f683da64e'
+  data.tar.gz: ad13fdcaf9caa12d724e54abaac56b096288a34f76881f15ff49ef008535911c6fbe7a334f653af89b10adee1cc3ef513c2b326aa68bfbc21f7efd3b46d06424

data/CHANGELOG.md

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Marc Heiligers
+
+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,115 @@
+# Proofsheet
+
+Proofsheet captures repeatable screenshots from web applications. A YAML manifest describes the browser viewport, authentication, pages, readiness selectors, clicks, safety checks, and element crops. The `proofsheet` CLI runs the manifest in headless Chrome and writes PNG files.
+
+## Installation
+
+Install the gem:
+
+```sh
+gem install proofsheet
+```
+
+Proofsheet requires Chrome and libvips on the machine doing the capture.
+
+## Manifest
+
+Create `proofsheet.yml` in the root of the project whose screenshots you want to capture:
+
+```yaml
+host: "https://example.com"
+
+expect:
+  username: "demo@example.com"
+
+credentials:
+  username: "env:PROOFSHEET_USERNAME"
+  password: "env:PROOFSHEET_PASSWORD"
+
+login:
+  path: "/sign-in"
+  username_field: "email"
+  password_field: "password"
+  submit: "Sign in"
+  expect:
+    selector: "header"
+    text: "demo@example.com"
+
+targets:
+  account: 42
+
+defaults:
+  viewport: [1440, 900]
+  output_dir: "docs/screenshots"
+
+shots:
+  dashboard:
+    path: "/accounts/%{account}"
+    wait_for: "[data-testid='dashboard']"
+    expect:
+      selector: ".account-name"
+      text: "Demo Account"
+
+  activity:
+    path: "/accounts/%{account}/activity"
+    wait_for: "[data-testid='activity-chart']"
+    click: "[data-range='7d']"
+    clip:
+      selector: "[data-testid='activity-chart']"
+      padding: 5
+
+  toolbar:
+    path: "/accounts/%{account}"
+    clip:
+      selector: ".toolbar"
+      full_width: true
+```
+
+The `login` section is optional; `credentials` is required when `login` is present. The `expect`, `targets`, `wait_for`, `click`, and `clip` sections are optional. The default viewport is `1440×900`, and the default output directory is `screenshots`.
+
+Credential sources must be environment variables such as `env:PROOFSHEET_USERNAME` or 1Password secret references such as `op://Vault/Item/username`. Add `op_account` under `credentials` when 1Password needs an explicit account.
+
+An `expect.username` value stops capture before Chrome starts if the loaded username is not the intended screenshot account. A login or shot-level `expect` stops capture when the expected text is absent from the selected element.
+
+For pages whose final URL is only discoverable in the browser, `path_script` may contain JavaScript that returns a path. Set `resolved_wait_for` to wait for the destination content:
+
+```yaml
+shots:
+  latest-report:
+    path: "/reports"
+    wait_for: "[data-latest-report]"
+    path_script: "document.querySelector('[data-latest-report]').getAttribute('href')"
+    resolved_wait_for: "iframe[title='Report']"
+```
+
+## CLI
+
+Capture every shot:
+
+```sh
+proofsheet capture
+```
+
+Capture selected shots, use another manifest, or override its host:
+
+```sh
+proofsheet capture dashboard activity
+proofsheet capture --config config/docs.yml
+proofsheet capture --host http://localhost:3000
+```
+
+List the manifest without starting Chrome:
+
+```sh
+proofsheet list
+```
+
+Relative output paths are resolved from the directory where the command runs.
+
+## Development
+
+Run `bin/setup`, then `bundle exec rake` to run the specs and linter. To install this gem locally, run `bundle exec rake install`.
+
+## License
+
+Proofsheet is available under the terms of the MIT License.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/proofsheet

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "proofsheet"
+
+exit Proofsheet::CLI.new(ARGV).run

data/lib/proofsheet/browser.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Proofsheet
+  class Browser
+    DRIVER = :proofsheet
+    LOAD_TIMEOUT = 20
+    SETTLE_TIME = 0.5
+
+    LOADED = <<~JS
+      document.readyState === "complete" &&
+        (!document.fonts || document.fonts.status === "loaded") &&
+        Array.from(document.querySelectorAll("iframe")).every(function (frame) {
+          try {
+            return !frame.contentDocument || frame.contentDocument.readyState === "complete";
+          } catch (e) {
+            return true;
+          }
+        })
+    JS
+
+    SCROLL_INTO_VIEW = <<~JS
+      arguments[0].style.scrollMargin = arguments[1] + "px";
+      arguments[0].scrollIntoView({block: "nearest"});
+    JS
+
+    def initialize(host:, viewport:)
+      @host = host
+      @width, @height = viewport
+    end
+
+    def start
+      require "capybara"
+      require "selenium-webdriver"
+
+      Capybara.register_driver(DRIVER) { |app| chrome(app) }
+      Capybara.run_server = false
+      Capybara.app_host = @host
+      Capybara.default_max_wait_time = 10
+
+      @session = Capybara::Session.new(DRIVER)
+      @session.visit("/")
+      fit_viewport
+      self
+    end
+
+    def quit
+      @session&.quit
+    end
+
+    def current_path
+      @session.current_path
+    end
+
+    def visit(path, wait_for: nil)
+      @session.visit(path)
+      @session.assert_selector(wait_for, visible: :all) if wait_for
+      Timeout.timeout(LOAD_TIMEOUT) { sleep 0.1 until @session.evaluate_script(LOADED) }
+      sleep SETTLE_TIME
+    end
+
+    def sign_in(login, username, password)
+      @session.visit(login.path)
+      @session.fill_in(login.username_field, with: username)
+      @session.fill_in(login.password_field, with: password)
+      @session.click_button(login.submit)
+    end
+
+    def shows?(selector, text)
+      @session.has_css?(selector, text: text)
+    end
+
+    def click(selector)
+      @session.find(selector).click
+      sleep SETTLE_TIME
+    end
+
+    def evaluate(script)
+      @session.evaluate_script(script)
+    end
+
+    def screenshot_png
+      @session.driver.browser.screenshot_as(:png)
+    end
+
+    def rect_for(selector, margin: 0)
+      node = @session.find(selector, match: :first)
+      @session.execute_script(SCROLL_INTO_VIEW, node, margin)
+      sleep SETTLE_TIME
+      @session.evaluate_script("arguments[0].getBoundingClientRect().toJSON()", node)
+    end
+
+    private
+
+    def chrome(app)
+      options = Selenium::WebDriver::Chrome::Options.new
+      ["--headless=new", "--hide-scrollbars", "--force-device-scale-factor=1",
+       "--window-size=#{@width},#{@height}", "--disable-dev-shm-usage", "--no-sandbox",
+       "--disable-gpu"].each { |argument| options.add_argument(argument) }
+      Capybara::Selenium::Driver.new(app, browser: :chrome, options: options)
+    end
+
+    def fit_viewport
+      inner = @session.evaluate_script("[window.innerWidth, window.innerHeight]")
+      return if inner == [@width, @height]
+
+      window = @session.driver.browser.manage.window
+      size = window.size
+      window.resize_to(size.width + (@width - inner[0]), size.height + (@height - inner[1]))
+    end
+  end
+end

data/lib/proofsheet/capturer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module Proofsheet
+  class Capturer
+    def initialize(manifest:, host:, root: Dir.pwd, credentials: nil, browser_class: Browser, out: $stdout)
+      @manifest = manifest
+      @host = host
+      @root = Pathname(root)
+      @credentials = credentials
+      @browser_class = browser_class
+      @out = out
+    end
+
+    def capture(names = @manifest.names)
+      shots = names.map { |name| @manifest.shot(name) }
+      username, password = authentication
+
+      @browser = @browser_class.new(host: @host, viewport: @manifest.viewport).start
+      sign_in(username, password) if @manifest.login
+      shots.each { |shot| capture_shot(shot) }
+    ensure
+      @browser&.quit
+    end
+
+    private
+
+    def authentication
+      return [nil, nil] unless @manifest.login
+
+      username = @credentials.username
+      expected = @manifest.expected_username
+      if expected && username != expected
+        raise Error, "credentials hold #{username.inspect} but the manifest expects #{expected.inspect}"
+      end
+
+      [username, @credentials.password]
+    end
+
+    def sign_in(username, password)
+      login = @manifest.login
+      @browser.sign_in(login, username, password)
+      verify(login.expectation, "sign in") if login.expectation
+    end
+
+    def capture_shot(shot)
+      @out.puts shot.name
+      @browser.visit(@manifest.path_for(shot), wait_for: shot.wait_for)
+      verify(shot.expectation, shot.name) if shot.expectation
+      resolve_path(shot) if shot.path_script
+      @browser.click(shot.click) if shot.click
+      write(shot, image_for(shot))
+    end
+
+    def resolve_path(shot)
+      path = @browser.evaluate(shot.path_script)
+      raise Error, "#{shot.name}: path_script did not return a path" if path.nil? || path.empty?
+
+      @browser.visit(path, wait_for: shot.resolved_wait_for)
+    end
+
+    def verify(expectation, context)
+      return if @browser.shows?(expectation.selector, expectation.text)
+
+      raise Error, "#{context}: #{@browser.current_path} does not show #{expectation.text.inspect}"
+    end
+
+    def image_for(shot)
+      return @browser.screenshot_png unless shot.clip?
+
+      rect = @browser.rect_for(shot.clip.selector, margin: shot.clip.padding)
+      require "vips"
+      image = Vips::Image.new_from_buffer(@browser.screenshot_png, "")
+      verify_scale(image)
+      crop(image, clip_for(shot, rect, image))
+    end
+
+    def crop(image, clip)
+      @out.puts "  cropped to #{clip}"
+      image.crop(clip.left, clip.top, clip.width, clip.height).write_to_buffer(".png")
+    end
+
+    def clip_for(shot, rect, image)
+      if rect["height"] > image.height
+        raise Error, "#{shot.name}: #{shot.clip.selector} is #{rect["height"].ceil}px tall, " \
+                     "taller than the #{image.height}px viewport"
+      end
+
+      Clip.from_rect(rect, image_width: image.width, image_height: image.height,
+                           full_width: shot.clip.full_width, padding: shot.clip.padding)
+    end
+
+    def verify_scale(image)
+      width = @manifest.viewport.first
+      return if image.width == width
+
+      raise Error, "captured #{image.width}px wide but the viewport is #{width}px"
+    end
+
+    def write(shot, png)
+      path = @root.join(@manifest.output_dir, shot.filename)
+      FileUtils.mkdir_p(path.dirname)
+      path.binwrite(png)
+      @out.puts "  wrote #{path.relative_path_from(@root)}"
+    end
+  end
+end

data/lib/proofsheet/cli.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Proofsheet
+  class CLI
+    USAGE = "Usage: proofsheet <capture [SHOT ...] | list> [--config PATH] [--host HOST]"
+
+    def initialize(argv, out: $stdout, err: $stderr, root: Dir.pwd, manifest_loader: Manifest.method(:load),
+                   capturer_class: Capturer)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @root = root
+      @manifest_loader = manifest_loader
+      @capturer_class = capturer_class
+    end
+
+    def run
+      command = @argv.shift
+      return help(0) if %w[help --help -h].include?(command)
+      return version if %w[--version -v].include?(command)
+      return help(1) unless %w[capture list].include?(command)
+
+      options = { config: Manifest::DEFAULT_PATH }
+      parser(options).parse!(@argv)
+      manifest = @manifest_loader.call(options[:config])
+
+      command == "list" ? list(manifest) : capture(manifest, options)
+      0
+    rescue OptionParser::ParseError, Error, KeyError => e
+      @err.puts "proofsheet: #{e.message}"
+      1
+    end
+
+    private
+
+    def parser(options)
+      OptionParser.new do |opts|
+        opts.on("-c", "--config PATH") { |path| options[:config] = path }
+        opts.on("--host HOST") { |host| options[:host] = host }
+      end
+    end
+
+    def list(manifest)
+      raise Error, "list does not accept shot names" unless @argv.empty?
+
+      manifest.shots.each { |shot| @out.puts "#{shot.name.ljust(20)} #{shot.path_template}" }
+    end
+
+    def capture(manifest, options)
+      host = options[:host] || manifest.host
+      raise Error, "host is missing from #{manifest.path}; pass --host HOST" if host.nil? || host.empty?
+
+      credentials = Credentials.new(manifest.credentials) if manifest.login
+      capturer = @capturer_class.new(manifest: manifest, host: host, root: @root,
+                                     credentials: credentials, out: @out)
+      names = @argv.empty? ? manifest.names : @argv
+      @out.puts "Capturing #{names.size} #{names.size == 1 ? "shot" : "shots"} from #{host}"
+      capturer.capture(names)
+      @out.puts "Done."
+    end
+
+    def help(status)
+      (status.zero? ? @out : @err).puts USAGE
+      status
+    end
+
+    def version
+      @out.puts Proofsheet::VERSION
+      0
+    end
+  end
+end

data/lib/proofsheet/clip.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Proofsheet
+  Clip = Data.define(:left, :top, :width, :height) do
+    def self.from_rect(rect, image_width:, image_height:, full_width: false, padding: 0)
+      left, width = full_width ? [0, image_width] : axis(rect["x"], rect["width"], image_width, padding)
+      top, height = axis(rect["y"], rect["height"], image_height, padding)
+
+      new(left: left, top: top, width: width, height: height)
+    end
+
+    def self.axis(offset, length, limit, padding)
+      start = (offset.floor - padding).clamp(0, limit - 1)
+
+      [start, (length.ceil + (padding * 2)).clamp(1, limit - start)]
+    end
+
+    def to_s
+      "#{width}×#{height} at #{left},#{top}"
+    end
+  end
+end

data/lib/proofsheet/credentials.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Proofsheet
+  class Credentials
+    def self.op_read(account, reference)
+      command = %w[op read]
+      command.push("--account", account) unless account.nil?
+      out, err, status = Open3.capture3(*command, reference)
+      return out if status.success?
+
+      raise Error, "#{reference}: #{err.strip.empty? ? "op read failed" : err.strip}"
+    end
+
+    def initialize(config, env: ENV, reader: Credentials.method(:op_read))
+      @config = config
+      @env = env
+      @reader = reader
+    end
+
+    def username
+      read(@config.fetch("username"))
+    end
+
+    def password
+      read(@config.fetch("password"))
+    end
+
+    private
+
+    def read(source)
+      value = case source
+              when %r{\Aop://}
+                @reader.call(@config["op_account"], source)
+              when /\Aenv:(.+)\z/
+                @env.fetch(Regexp.last_match(1))
+              else
+                raise Error, "credential sources must be an env:VARIABLE or op:// reference"
+              end
+
+      value.to_s.strip.then { |result| result.empty? ? raise(Error, "#{source} is empty") : result }
+    rescue Errno::ENOENT
+      raise Error, "the 1Password CLI is not installed"
+    rescue KeyError => e
+      raise Error, e.message
+    end
+  end
+end

data/lib/proofsheet/manifest.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Proofsheet
+  class Manifest
+    ClipSpec = Data.define(:selector, :full_width, :padding)
+    Expectation = Data.define(:selector, :text)
+    Login = Data.define(:path, :username_field, :password_field, :submit, :expectation)
+
+    Shot = Data.define(:name, :path_template, :wait_for, :click, :clip, :expectation,
+                       :path_script, :resolved_wait_for) do
+      def clip?
+        !clip.nil?
+      end
+
+      def filename
+        "#{name}.png"
+      end
+    end
+
+    DEFAULT_PATH = "proofsheet.yml"
+
+    def self.load(path = DEFAULT_PATH)
+      new(YAML.safe_load_file(path), path: path)
+    rescue Errno::ENOENT
+      raise Error, "manifest not found: #{path}"
+    rescue Psych::Exception => e
+      raise Error, "could not read #{path}: #{e.message}"
+    end
+
+    attr_reader :path
+
+    def initialize(data, path: DEFAULT_PATH)
+      @data = data
+      @path = path
+    end
+
+    def host
+      @data["host"]
+    end
+
+    def expected_username
+      @data.dig("expect", "username")
+    end
+
+    def viewport
+      defaults.fetch("viewport", [1440, 900])
+    end
+
+    def output_dir
+      defaults.fetch("output_dir", "screenshots")
+    end
+
+    def credentials
+      @data.fetch("credentials")
+    end
+
+    def login
+      raw = @data["login"]
+      return if raw.nil?
+
+      Login.new(path: raw.fetch("path"), username_field: raw.fetch("username_field"),
+                password_field: raw.fetch("password_field"), submit: raw.fetch("submit"),
+                expectation: expectation(raw["expect"]))
+    end
+
+    def names
+      shot_data.keys
+    end
+
+    def shots
+      names.map { |name| shot(name) }
+    end
+
+    def shot(name)
+      raw = shot_data[name]
+      raise Error, "unknown shot #{name.inspect} — known shots: #{names.join(", ")}" if raw.nil?
+
+      Shot.new(name: name, path_template: raw.fetch("path"), wait_for: raw["wait_for"],
+               click: raw["click"], clip: clip_spec(raw["clip"]), expectation: expectation(raw["expect"]),
+               path_script: raw["path_script"], resolved_wait_for: raw["resolved_wait_for"])
+    rescue KeyError => e
+      raise Error, "#{name}: #{e.message} in #{@path}"
+    end
+
+    def path_for(shot)
+      shot.path_template.gsub(/%\{(\w+)\}/) do
+        key = Regexp.last_match(1)
+        raise Error, "#{shot.name}: no target named #{key.inspect} in #{@path}" unless targets.key?(key)
+
+        value = targets[key]
+        raise Error, "#{shot.name}: targets.#{key} is not set in #{@path}" if value.nil? || value.empty?
+
+        value
+      end
+    end
+
+    private
+
+    def defaults
+      @data.fetch("defaults", {})
+    end
+
+    def clip_spec(raw)
+      return if raw.nil?
+
+      ClipSpec.new(selector: raw.fetch("selector"), full_width: raw.fetch("full_width", false),
+                   padding: raw.fetch("padding", 0))
+    end
+
+    def expectation(raw)
+      return if raw.nil?
+
+      Expectation.new(selector: raw.fetch("selector"), text: raw.fetch("text"))
+    end
+
+    def targets
+      @targets ||= @data.fetch("targets", {}).transform_values { |value| value&.to_s }
+    end
+
+    def shot_data
+      @data.fetch("shots")
+    rescue KeyError
+      raise Error, "shots is missing from #{@path}"
+    end
+  end
+end

data/lib/proofsheet/version.rb

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

data/lib/proofsheet.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "proofsheet/version"
+
+module Proofsheet
+  class Error < StandardError
+  end
+end
+
+require_relative "proofsheet/browser"
+require_relative "proofsheet/clip"
+require_relative "proofsheet/credentials"
+require_relative "proofsheet/manifest"
+require_relative "proofsheet/capturer"
+require_relative "proofsheet/cli"

data/sig/proofsheet.rbs

@@ -0,0 +1,4 @@
+module Proofsheet
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: proofsheet
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Marc Heiligers
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.40'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.40'
+- !ruby/object:Gem::Dependency
+  name: ruby-vips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Automate screenshots from web apps for your documentation, landings pages
+  and emails
+email:
+- marc@eternal.co.za
+executables:
+- proofsheet
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/proofsheet
+- lib/proofsheet.rb
+- lib/proofsheet/browser.rb
+- lib/proofsheet/capturer.rb
+- lib/proofsheet/cli.rb
+- lib/proofsheet/clip.rb
+- lib/proofsheet/credentials.rb
+- lib/proofsheet/manifest.rb
+- lib/proofsheet/version.rb
+- sig/proofsheet.rbs
+homepage: https://github.com/FASCINATION-works/proofsheet
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/FASCINATION-works/proofsheet
+  changelog_uri: https://github.com/FASCINATION-works/proofsheet/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/FASCINATION-works/proofsheet/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Capture repeatable screenshots from web applications
+test_files: []