cyperful 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e6cdf194b4606ed00df58d8b28820efb2bcf69f5a3f636ec5fed096fc8ce84e
+  data.tar.gz: 98ebee3f3b456c6d2fcaa905b19e1408503e1c2341926dd9d2b808c31287ef42
+SHA512:
+  metadata.gz: da33579e39387049c628a5d6a1d52dac4d56fffdc754671fd3928d22bb9cdf4149d597637beab80413e68eac719b6ee4607fc88acc39803568365240dac3f2b2
+  data.tar.gz: b5ee454173523ea078cf592aa2861541522514695bb50c7cdd0a42bb49c9b67359ef5493c55629cd1be2ff7ea3e40946f17e889be009cb27520803f6883ca637

data/lib/cyperful/test_parser.rb

@@ -0,0 +1,78 @@
+require "parser/current"
+
+class Cyperful::TestParser
+  def initialize(test_class)
+    @test_class = test_class
+    @source_filepath = Object.const_source_location(test_class.name).first
+  end
+
+  def steps_per_test
+    ast = Parser::CurrentRuby.parse(File.read(@source_filepath))
+
+    test_class_name = @test_class.name.to_sym
+
+    system_test_class =
+      ast.children.find do |node|
+        if node.type == :class
+          node.children.find do |c|
+            c.type == :const && c.children[1] == test_class_name
+          end
+        end
+      end
+    unless system_test_class
+      raise "Could not find class #{test_class.name} in #{@source_filepath}"
+    end
+
+    (
+        # the children of the `class` node are either:
+        # - a `begin` node if there's more than 1 child node
+        # - or the one 0 or 1 child node
+        system_test_class
+          .children
+          .find { |node| node.type == :begin }
+          &.children || [system_test_class.children[2]].compact
+      )
+      .map do |node|
+        # e.g. `test "my test" do ... end`
+        if node.type == :block && node.children[0].type == :send &&
+             node.children[0].children[1] == :test
+          test_string = node.children[0].children[2].children[0]
+
+          # https://github.com/rails/rails/blob/66676ce499a32e4c62220bd05f8ee2cdf0e15f0c/activesupport/lib/active_support/testing/declarative.rb#L14C23-L14C61
+          test_method = "test_#{test_string.gsub(/\s+/, "_")}".to_sym
+
+          block_node = node.children[2]
+          [test_method, block_node]
+        else
+          # e.g. `def test_my_test; ... end`
+          # TODO
+        end
+      end
+      .compact
+      .to_h do |test_method, block_node|
+        [
+          test_method,
+          find_test_steps(block_node)
+            # sanity check:
+            .uniq { |step| step[:line] },
+        ]
+      end
+  end
+
+  private def find_test_steps(ast, out = [])
+    return out unless ast&.is_a?(Parser::AST::Node)
+
+    if ast.type == :send && Cyperful.step_at_methods.include?(ast.children[1])
+      out << {
+        method: ast.children[1],
+        line: ast.loc.line,
+        column: ast.loc.column,
+        as_string: ast.loc.expression.source,
+      }
+    end
+
+    ast.children.each { |child| find_test_steps(child, out) }
+
+    out
+  end
+end

data/lib/cyperful/ui_server.rb

@@ -0,0 +1,125 @@
+require "webrick/websocket"
+
+module FixWebrickWebsocketServer
+  def service(req, res)
+    # fix for: webrick-websocket incorrectly assumes `Upgrade` header is always present
+    req.header["upgrade"] = [""] if req["upgrade"].nil?
+    super
+  end
+end
+WEBrick::Websocket::HTTPServer.prepend(FixWebrickWebsocketServer)
+
+class Cyperful::UiServer
+  def initialize(port:)
+    @port = port
+
+    @notify_queue = Queue.new
+
+    build_server
+  end
+
+  def url_origin
+    "http://localhost:#{@port}"
+  end
+
+  def notify(data)
+    @notify_queue.enq(data)
+  end
+
+  def on_command(&block)
+    @on_command = block
+  end
+
+  private def build_server
+    @server =
+      WEBrick::Websocket::HTTPServer.new(
+        Port: @port,
+        DocumentRoot: File.expand_path("../../public", __dir__),
+        Logger: WEBrick::Log.new("/dev/null"),
+        AccessLog: [],
+      )
+
+    notify_queue = @notify_queue
+
+    sock_num_counter = 0
+    open_sockets = []
+
+    @server.mount(
+      "/api/websocket",
+      Class.new(WEBrick::Websocket::Servlet) do
+        # use `define_method` so we can access outer scope variables i.e. `notify_queue`
+        define_method(:socket_open) do |sock|
+          # this would be an unexpected state,
+          # at the moment it's not possible to have more than one client connected.
+          # TODO: handle the client unexpectedly disconnecting e.g. user changes browser url
+          if open_sockets.length > 0
+            warn "Warning: websockets already open: #{open_sockets}. You probably need to restart."
+          end
+
+          sock_num = sock_num_counter
+          sock_num_counter += 1
+
+          open_sockets << sock_num
+          sock.instance_variable_set(:@sock_num, sock_num)
+
+          # puts "Websocket #{sock_num} opened."
+          loop do
+            data = notify_queue.deq
+
+            # puts "Websocket #{sock_num} got: #{data.class.name}"
+            break unless data
+            sock.puts(data.to_json)
+          end
+        rescue => err
+          warn "Error in websocket #{sock_num}: #{err}"
+          sock.close
+        end
+
+        define_method(:socket_close) do |sock|
+          sock_num = sock.instance_variable_get(:@sock_num)
+
+          # puts "Websocket #{sock_num} closed!"
+          open_sockets.delete(sock_num)
+        end
+      end,
+    )
+
+    # should we use websocket events for this?
+    @server.mount_proc("/api/steps/command") do |req, res|
+      if req.request_method != "POST"
+        res.body = "Only POST allowed"
+        res.status = 405
+        next
+      end
+
+      command, params = JSON.parse(req.body).values_at("command", "params")
+
+      if @on_command
+        begin
+          @on_command.call(command, params)
+        rescue => err
+          res.body = "Error: #{err}"
+          res.status = 500
+          next
+        end
+      end
+
+      res.status = 204
+    end
+  end
+
+  def start_async
+    # start server in background i.e. non-blocking
+    @thread =
+      Thread.new do
+        Thread.current.abort_on_exception = true
+        @server.start
+      end
+  end
+
+  def shutdown
+    @thread&.kill
+
+    @server.shutdown
+  end
+end

data/lib/cyperful.rb

@@ -0,0 +1,475 @@
+require "capybara"
+require "listen"
+
+module Cyperful
+  @current = nil
+
+  def self.current
+    @current
+  end
+  def self.setup(test_class, test_name)
+    puts "Setting up Cyperful for: #{test_class}##{test_name}"
+
+    # must set `Cyperful.current` before calling `async_setup`
+    @current ||= Cyperful::SystemSteps.new
+    @current.set_current_test(test_class, test_name)
+
+    nil
+  rescue => err
+    unless err.is_a?(Cyperful::AbstractCommand)
+      warn "Error setting up Cyperful:\n\n#{err.message}\n#{err.backtrace.slice(0, 4).join("\n")}\n"
+    end
+
+    raise err
+  end
+
+  def self.teardown(error = nil)
+    @current&.teardown(error)
+  end
+
+  # more potential methods: https://www.rubydoc.info/github/jnicklas/capybara/Capybara/Session
+  @step_at_methods = [*Capybara::Session::NODE_METHODS, :visit, :refresh]
+  def self.step_at_methods
+    @step_at_methods
+  end
+  def self.add_step_at_methods(*mods_or_methods)
+    mods_or_methods.each do |mod_or_method|
+      case mod_or_method
+      when Module
+        @step_at_methods +=
+          mod_or_method.methods(false) + mod_or_method.instance_methods(false)
+      when String, Symbol
+        @step_at_methods << mod_or_method.to_sym
+      else
+        raise "Expected Module or Array of strings/symbols, got #{mod_or_method.class}"
+      end
+    end
+  end
+end
+
+require "cyperful/test_parser"
+require "cyperful/ui_server"
+
+class Cyperful::AbstractCommand < StandardError
+end
+class Cyperful::ResetCommand < Cyperful::AbstractCommand
+end
+class Cyperful::ExitCommand < Cyperful::AbstractCommand
+end
+
+class Cyperful::SystemSteps
+  attr_reader :steps, :pausing
+
+  SCREENSHOTS_DIR = File.expand_path("../public/screenshots", __dir__)
+
+  def initialize
+    @step_pausing_queue = Queue.new
+
+    @session = Capybara.current_session
+    raise "Could not find Capybara session" unless @session
+
+    setup_api_server
+  end
+
+  def set_current_test(test_class, test_name)
+    @test_class = test_class
+    @test_name = test_name.to_sym
+
+    @source_filepath =
+      Object.const_source_location(test_class.name).first ||
+        (raise "Could not find source file for #{test_class.name}")
+
+    reset_steps
+
+    print_steps
+
+    @session.visit(@cyperful_origin)
+    drive_iframe
+
+    # after we setup our UI, send the initialization data
+    notify_updated_steps
+
+    setup_tracing
+
+    setup_file_listener
+
+    # Sanity check
+    unless @step_pausing_queue.empty?
+      raise "step_pausing_queue is not empty during setup"
+    end
+
+    # Wait for the user to click "Start"
+    step_pausing_dequeue
+  end
+
+  def step_pausing_dequeue
+    command = @step_pausing_queue.deq
+    if command == :reset
+      raise Cyperful::ResetCommand
+    elsif command == :exit
+      raise Cyperful::ExitCommand
+    elsif command == :next
+      # just continue
+    else
+      raise "unknown command: #{command}"
+    end
+  end
+
+  def reset_steps
+    # TODO: memoize this when there's multiple tests per file
+    @steps =
+      Cyperful::TestParser.new(@test_class).steps_per_test.fetch(@test_name)
+
+    editor = "vscode" # TODO: support other editors?
+
+    @steps.each_with_index do |step, i|
+      step.merge!(
+        index: i,
+        status: "pending",
+        start_at: nil,
+        end_at: nil,
+        paused_at: nil,
+        permalink: "#{editor}://file/#{@source_filepath}:#{step.fetch(:line)}",
+      )
+    end
+
+    @step_per_line = @steps.index_by { |step| step[:line] }
+
+    @current_step = nil
+
+    @pause_at_step = true
+
+    @test_result = nil
+
+    # reset SCREENSHOTS_DIR
+    FileUtils.rm_rf(SCREENSHOTS_DIR)
+    FileUtils.mkdir_p(SCREENSHOTS_DIR)
+  end
+
+  # subscribe to the execution of each line of code in the test.
+  # this let's us notify the frontend of the line's status, and pause execution if needed.
+  def setup_tracing
+    @tracepoint&.disable
+
+    @tracepoint =
+      TracePoint.new(:line) do |tp|
+        next if @source_filepath.nil? || tp.path != @source_filepath
+
+        finish_current_step
+
+        step = @step_per_line[tp.lineno]
+        pause_on_step(step) if step
+      end
+    @tracepoint.enable
+  end
+
+  # Every time a file changes the `test/` directory,
+  # reset this test
+  # TODO: add an option to auto-run
+  def setup_file_listener
+    test_dir = @source_filepath.match(%r{^/.+/(test|spec)\b})[0]
+
+    @file_listener&.stop
+    @file_listener =
+      Listen.to(test_dir) do |_modified, _added, _removed|
+        puts "Test files changed, resetting test..."
+
+        @pause_at_step = true
+        @step_pausing_queue.enq(:reset)
+      end
+    @file_listener.start
+  end
+
+  def print_steps
+    puts "#{@steps.length} steps:"
+    @steps.each do |step|
+      puts "  #{step[:method]}: #{step[:line]}:#{step[:column]}"
+    end
+    puts
+  end
+
+  # pending (i.e. test hasn't started), paused, running, passed, failed
+  def test_status
+    return @test_result[:status] if @test_result # passed or failed
+
+    if @pause_at_step
+      return "running" if @steps.any? { |step| step[:status] == "running" }
+
+      return "pending" unless @current_step
+      return "paused"
+    end
+
+    "running"
+  end
+
+  def test_duration_ms
+    start_at = @steps.first&.[](:start_at)
+    return nil unless start_at
+    last_ended_step_i = @steps.rindex { |step| step[:end_at] }
+    return nil unless last_ended_step_i
+
+    end_at = @steps[last_ended_step_i][:end_at]
+
+    duration = end_at - start_at
+
+    @steps.each_with_index do |step, i|
+      next if i == 0 || i > last_ended_step_i
+      if step[:paused_at] && step[:start_at]
+        duration -= (step[:start_at] - step[:paused_at])
+      end
+    end
+
+    duration
+  end
+
+  def steps_updated_data
+    status = self.test_status
+    {
+      event: "steps_updated",
+      steps: @steps,
+      current_step_index: @current_step&.[](:index),
+      pause_at_step: @pause_at_step,
+      test_suite: @test_class.name,
+      test_name: @test_name,
+      test_status: status,
+      test_error: @test_result&.[](:error)&.to_s,
+      test_duration_ms: test_duration_ms,
+    }
+  end
+
+  private def notify_updated_steps
+    @ui_server.notify(steps_updated_data)
+  end
+
+  private def finish_current_step(error = nil)
+    if @current_step
+      @current_step[:end_at] = (Time.now.to_f * 1000.0).to_i
+      @current_step[:status] = !error ? "passed" : "failed"
+
+      # take screenshot after the step has finished
+      # path = File.join(SCREENSHOTS_DIR, "#{@current_step[:index]}.png")
+
+      # FIXME: this adds ~200ms to each step! disabling it for now
+      # @session.save_screenshot(path)
+
+      # this adds ~70ms to each step, but causes a weird flash on the screen
+      # @session.find(:css, "body").base.native.save_screenshot(path)
+
+      @current_step = nil
+    end
+
+    notify_updated_steps
+  end
+
+  def pause_on_step(step)
+    @current_step = step
+
+    puts "STEP: #{step[:as_string]}"
+
+    if @pause_at_step == true || @pause_at_step == step[:index]
+      @current_step[:paused_at] = (Time.now.to_f * 1000.0).to_i
+      @current_step[:status] = "paused"
+      notify_updated_steps
+
+      # async wait for `continue_next_step`
+      step_pausing_dequeue
+    end
+
+    @current_step[:status] = "running"
+    @current_step[:start_at] = (Time.now.to_f * 1000.0).to_i
+    notify_updated_steps
+  end
+
+  private def continue_next_step
+    @step_pausing_queue.enq(:next)
+  end
+
+  def drive_iframe
+    puts "Driving iframe..."
+
+    @session.switch_to_frame(
+      @session.find(:css, "iframe#scenario-frame"), # waits for the iframe to load
+    )
+    @driving_iframe = true
+  end
+
+  # forked from: https://github.com/teamcapybara/capybara/blob/master/lib/capybara/session.rb#L264
+  private def make_absolute_url(visit_uri)
+    visit_uri = ::Addressable::URI.parse(visit_uri.to_s)
+    base_uri =
+      ::Addressable::URI.parse(@session.config.app_host || @session.server_url)
+
+    if base_uri && [nil, "http", "https"].include?(visit_uri.scheme)
+      if visit_uri.relative?
+        visit_uri_parts = visit_uri.to_hash.compact
+
+        # Useful to people deploying to a subdirectory
+        # and/or single page apps where only the url fragment changes
+        visit_uri_parts[:path] = base_uri.path + visit_uri.path
+
+        visit_uri = base_uri.merge(visit_uri_parts)
+      end
+      # adjust_server_port(visit_uri)
+    end
+
+    abs_url = visit_uri.to_s
+
+    display_url = abs_url.sub(base_uri.to_s, "")
+
+    [abs_url, display_url]
+  end
+
+  WATCHER_JS = File.read(File.join(__dir__, "../watcher.js"))
+
+  def internal_visit(url)
+    return false unless @driving_iframe
+
+    abs_url, display_url = make_absolute_url(url)
+
+    # show the actual `visit` url as soon as it's computed
+    if @current_step && @current_step[:method] == :visit
+      @current_step[:as_string] = "visit #{display_url.to_json}"
+      notify_updated_steps
+    end
+
+    @session.execute_script("window.location.href = #{abs_url.to_json}")
+
+    # inject the watcher script into the page being tested.
+    # this script will notify the Cyperful UI for events like:
+    # console logs, network requests, client navigations, errors, etc.
+    @session.execute_script(WATCHER_JS) # ~9ms empirically
+
+    true
+  end
+
+  def internal_current_url
+    return nil unless @driving_iframe
+
+    @session.evaluate_script("window.location.href")
+  end
+
+  def setup_api_server
+    @ui_server = Cyperful::UiServer.new(port: 3004)
+
+    @cyperful_origin = @ui_server.url_origin
+
+    @ui_server.on_command do |command, params|
+      case command
+      when "start"
+        # one of: integer (index of a step), true (pause at every step), or nil (don't pause)
+        @pause_at_step = params["pause_at_step"]
+
+        continue_next_step
+      when "reset"
+        @pause_at_step = true
+        @step_pausing_queue.enq(:reset)
+      when "stop"
+        @pause_at_step = true # enable pausing
+      when "exit"
+        @pause_at_step = true
+
+        # instead of calling `exit` directly, we need to raise a Cyperful::ExitCommand error
+        # so Minitest can finish it's teardown e.g. to reset the database
+        @step_pausing_queue.enq(:exit)
+      else
+        raise "unknown command: #{command}"
+      end
+    end
+
+    @ui_server.start_async
+
+    # The server appears to always stop on it's own,
+    # so we don't need to stop it within an `at_exit` or `Minitest.after_run`
+
+    puts "Cyperful server started: #{@cyperful_origin}"
+  end
+
+  def teardown(error = nil)
+    @tracepoint&.disable
+    @tracepoint = nil
+
+    @file_listener&.stop
+    @file_listener = nil
+
+    if error&.is_a?(Cyperful::ResetCommand)
+      puts "\nPlease ignore the error, we're just resetting the test ;)"
+
+      @ui_server.notify(nil) # `break` out of the `loop` (see `UiServer#socket_open`)
+
+      at_exit { Minitest.run_one_method(@test_class, @test_name) }
+      return
+    end
+
+    return if error&.is_a?(Cyperful::ExitCommand)
+
+    if error
+      # backtrace = error.backtrace.select { |s| s.include?(@source_filepath) }
+      backtrace = error.backtrace.slice(0, 4)
+      warn "\n\nTest failed with error:\n#{error.message}\n#{backtrace.join("\n")}"
+    end
+
+    @test_result = { status: error ? "failed" : "passed", error: error }
+
+    finish_current_step(error)
+
+    @ui_server.notify(nil) # `break` out of the `loop` (see `UiServer#socket_open`)
+
+    puts "Cyperful teardown complete. Waiting for command..."
+    command = @step_pausing_queue.deq
+    if command == :reset
+      at_exit { Minitest.run_one_method(@test_class, @test_name) }
+    end
+  end
+end
+
+module PrependCapybaraSession
+  # we need to override the following methods because they
+  # control the top-level browser window, but we want them
+  # to control the iframe instead
+
+  def visit(url)
+    return if Cyperful.current&.internal_visit(url)
+    super
+  end
+
+  def current_url
+    url = Cyperful.current&.internal_current_url
+    return url if url
+    super
+  end
+
+  def refresh
+    return if Cyperful.current&.internal_visit(current_url)
+    super
+  end
+end
+Capybara::Session.prepend(PrependCapybaraSession)
+
+module Cyperful::SystemTestHelper
+  def setup
+    Cyperful.setup(self.class, self.method_name)
+    super
+  end
+
+  def teardown
+    error = passed? ? nil : failure
+
+    error = error.error if error.is_a?(Minitest::UnexpectedError)
+
+    Cyperful.teardown(error)
+    super
+  end
+end
+
+# we need to allow the iframe to be embedded in the cyperful server
+# TODO: use Rack middleware instead to support non-Rails apps
+if const_defined?(:Rails)
+  Rails.application.config.content_security_policy do |policy|
+    policy.frame_ancestors(:self, "localhost:3004")
+  end
+else
+  warn "Cyperful: Rails not detected, skipping content_security_policy"
+end
+
+# fix for: Set-Cookie (SameSite=Lax) doesn't work when within an iframe with host 127.0.0.1
+Capybara.server_host = "localhost"

data/watcher.js

@@ -0,0 +1,151 @@
+(() => {
+  const log = console.log;
+
+  log('Cyperful watcher loading...');
+
+  const CYPERFUL_ORIGIN = 'http://localhost:3004';
+
+  let idCounter = 0;
+  const notify = (type, data, startEvent = null) => {
+    let evt;
+    try {
+      const timestamp = Date.now();
+      const id = `${timestamp}-${idCounter++}`;
+
+      if (data.url != null) {
+        try {
+          const url = new URL(data.url, window.location.origin);
+
+          // don't show our own requests
+          if (url.origin === CYPERFUL_ORIGIN) return null;
+
+          if (url.origin === window.location.origin) {
+            data.url = url.pathname + url.search + url.hash;
+          }
+        } catch (_err) {
+          // e.g. invalid URL
+        }
+      }
+
+      evt = {
+        type,
+        data,
+        id,
+        timestamp,
+        start_id: startEvent ? startEvent.id : undefined,
+      };
+
+      window.parent.postMessage(evt, CYPERFUL_ORIGIN);
+    } catch (_err) {
+      // e.g. blocked by CORS
+      // e.g. invalid payload
+    }
+    return evt || {};
+  };
+
+  // capture console logs
+  for (const level of ['log', 'error', 'warn', 'info', 'dir', 'debug']) {
+    const original = console[level];
+    if (!original) continue;
+    console[level] = (...args) => {
+      original.apply(console, args);
+      notify('log', { level, args });
+    };
+  }
+
+  // capture global errors
+  window.addEventListener('error', (event) => {
+    notify('global_error', { message: event.error.toString() });
+  });
+  window.addEventListener('unhandledrejection', (event) => {
+    notify('unhandledrejection', { message: event.reason.toString() });
+  });
+
+  // capture XHR network requests
+  const OriginalXHR = window.XMLHttpRequest;
+  function XHR() {
+    const xhr = new OriginalXHR();
+    const originalOpen = xhr.open;
+    xhr.open = (...args) => {
+      const start = notify('xhr', {
+        method: args[0],
+        url: args[1],
+        // body: args[2],
+      });
+      xhr.addEventListener('load', () => {
+        if (start)
+          notify(
+            'xhr:finished',
+            { status: xhr.status, response: xhr.response },
+            start,
+          );
+      });
+      return originalOpen.apply(this, args);
+    };
+    return xhr;
+  }
+  window.XMLHttpRequest = XHR;
+
+  // capture fetch network requests
+  const originalFetch = window.fetch;
+  window.fetch = (...args) => {
+    const [url, options] =
+      typeof args[0] === 'string' ? args : [args[0].url, args[0]];
+    const method = options?.method ?? 'GET';
+    const body = options?.body;
+
+    const start = notify('fetch', {
+      method,
+      url,
+      body,
+      bodyType:
+        options.headers?.['content-type'] ||
+        options.headers?.['Content-Type'] ||
+        null,
+    });
+
+    const promise = originalFetch(...args);
+    promise
+      .then(async (response) => {
+        const ct = response.headers.get('content-type') || '';
+        const resBody = ct.includes('application/json')
+          ? await response.clone().json()
+          : ct.includes('text/')
+          ? await response.clone().text()
+          : `[[ Unhandled content-type: ${ct || '<empty>'} ]]`;
+
+        if (start)
+          notify(
+            'fetch:finished',
+            {
+              status: response.status,
+              responseType: ct || null,
+              response: resBody,
+            },
+            start,
+          );
+      })
+      .catch(() => {});
+    return promise;
+  };
+
+  // capture client-side location changes
+  const originalPushState = history.pushState;
+  history.pushState = (...args) => {
+    originalPushState.apply(history, args);
+    notify('client_navigate', {
+      url: location.href,
+      replace: false,
+    });
+  };
+  const originalReplaceState = history.replaceState;
+  history.replaceState = (...args) => {
+    originalReplaceState.apply(history, args);
+    notify('client_navigate', {
+      url: location.href,
+      replace: true,
+    });
+  };
+
+  log('Cyperful watcher loaded.');
+})();

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: cyperful
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- me@wyattades.com
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: webrick-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cyperful.rb
+- lib/cyperful/test_parser.rb
+- lib/cyperful/ui_server.rb
+- watcher.js
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Cypress-esque testing for Capybara tests
+test_files: []