capybara-storyboard 0.1.0

data/lib/capybara/storyboard/policies/target_list_policy.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Storyboard
+    module Policies
+      # Restricts screenshots to an explicit set of test files. The set holds
+      # already-normalized paths (see Capybara::Storyboard.normalize_test_path);
+      # #call normalizes the context's raw test_file the same way before matching.
+      #
+      # An empty set means "explicitly no targets" and always returns false. The
+      # backward-compatible "capture everything" behavior is handled upstream by
+      # default_policy, which simply never constructs this policy when no target
+      # list is configured.
+      class TargetListPolicy
+        def initialize(paths)
+          @paths = Set.new(paths)
+        end
+
+        def call(context)
+          return false if @paths.empty?
+
+          test_file = context&.test_file
+          return false if test_file.nil?
+
+          @paths.include?(Capybara::Storyboard.normalize_test_path(test_file))
+        end
+      end
+    end
+  end
+end

data/lib/capybara/storyboard/session.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+module Capybara
+  module Storyboard
+    # Per-example state (sequence counter, output directory, enabled flag,
+    # example metadata) plus filename / path / sanitize derivation.
+    #
+    # Extracting this state out of TestHelper keeps its unit tests independent
+    # of Capybara and RSpec hooks: a Session can be built with a plain example
+    # double and an injected +output_root+.
+    class Session
+      def initialize(example:, enabled:, output_root: nil)
+        @example = example
+        @enabled = enabled
+        @output_root = output_root
+        @index = 0
+        @dir = nil
+        @suppression_depth = 0
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      # Automatic screenshot for a DSL action. No-op unless enabled.
+      def auto(page, action, detail = nil)
+        return unless @enabled
+        return if suppressed?
+
+        label = [action, sanitize(detail)].compact_blank.join('_')
+        capture_with_label(page, label)
+      end
+
+      # Manual screenshot hook. Like #auto, captured only when enabled. For an
+      # unconditional screenshot, use Capybara's own save_screenshot. The page
+      # is passed explicitly rather than held as state.
+      def manual(page, label)
+        return unless @enabled
+        return if suppressed?
+
+        capture_with_label(page, sanitize(label))
+      end
+
+      # Suppresses automatic/manual captures for the duration of the block. Used
+      # to skip nested captures while a confirm/alert dialog is open, where a
+      # screenshot or JS eval would raise UnexpectedAlertOpenError. A depth counter
+      # (not a boolean) supports nesting; the ensure guarantees reset on exceptions.
+      def suppress_captures
+        @suppression_depth += 1
+        yield
+      ensure
+        @suppression_depth -= 1
+      end
+
+      def suppressed?
+        @suppression_depth.positive?
+      end
+
+      private
+
+      def capture_with_label(page, label)
+        ensure_dir!
+        @index += 1
+        filename = "#{format('%03d', @index)}_#{label}.png"
+        wait_for_stable_page(page)
+        save_screenshot_safely(page, @dir.join(filename))
+      end
+
+      # A screenshot is a side effect; an unexpected failure (e.g. a dialog left
+      # open) must never break the test body. Mirrors PageStability's warn
+      # convention. There is no expected non-JS-driver case here, so warn always.
+      # (Named "safely" rather than +save_screenshot+ to avoid colliding with
+      # Capybara's DSL debugger method, which RuboCop's Lint/Debugger flags.)
+      def save_screenshot_safely(page, path)
+        page.save_screenshot(path)
+      rescue StandardError => e
+        warn("capybara-storyboard: screenshot skipped after error: #{e.class}: #{e.message}")
+      end
+
+      # Both callers (#auto / #manual) are already enabled-gated, so this always
+      # runs before an actual capture and never on a disabled session.
+      def wait_for_stable_page(page)
+        config = Capybara::Storyboard.configuration
+        PageStability.wait_for_stable_page(
+          page,
+          interval: config.page_stability_interval,
+          max_attempts: config.page_stability_max_attempts,
+          excluded_animations: config.page_stability_excluded_animations
+        )
+      end
+
+      def ensure_dir!
+        @dir ||= output_dir
+        FileUtils.mkdir_p(@dir)
+      end
+
+      def output_dir
+        (@output_root || default_output_root).join(spec_relative_dir, example_name)
+      end
+
+      # The output root when none is injected: the configuration's output_dir
+      # (default <base>/tmp/screenshots, overridable via Storyboard.configure).
+      def default_output_root
+        Capybara::Storyboard.configuration.output_dir
+      end
+
+      # Mirrors the spec file's location as the output directory tree, so
+      # screenshots for spec/system/foo_spec.rb land under system/foo/. The
+      # spec/ prefix and the _spec.rb (or .rb) suffix are dropped; each
+      # remaining path segment is sanitized while the / separators are kept.
+      def spec_relative_dir
+        raw = @example.metadata[:file_path]
+        return 'spec' if raw.blank?
+
+        relative = Capybara::Storyboard.normalize_test_path(raw)
+        segments = relative.split('/')
+        segments.shift if segments.first == 'spec'
+        segments[-1] = strip_spec_suffix(segments.last) if segments.any?
+
+        sanitized = segments.map { |segment| sanitize(segment) }.reject(&:blank?)
+        sanitized.empty? ? 'spec' : sanitized.join('/')
+      end
+
+      # Drops the trailing _spec.rb, falling back to a plain .rb, so a spec
+      # basename becomes its bare name (hoge_spec.rb -> hoge, hoge.rb -> hoge).
+      def strip_spec_suffix(basename)
+        basename.sub(/_spec\.rb\z/, '').sub(/\.rb\z/, '')
+      end
+
+      def example_name
+        name = sanitize(@example.description).truncate(80, omission: '')
+        return name if name.present?
+
+        fallback = sanitize(@example.full_description)
+        fallback.present? ? fallback.truncate(80, omission: '') : 'example'
+      end
+
+      # \p{Word} (Unicode word characters) rather than \w (ASCII-only) so that
+      # non-ASCII descriptions/labels (e.g. Japanese) are preserved in filenames
+      # and directory names instead of collapsing to underscores.
+      def sanitize(text)
+        text.to_s.gsub(/[^\p{Word}-]/, '_').gsub(/_+/, '_').gsub(/\A_|_\z/, '')
+      end
+    end
+  end
+end

data/lib/capybara/storyboard/test_helper.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Capybara
+  module Storyboard
+    # RSpec system-spec helper. Include AFTER Capybara::DSL so the overrides
+    # below chain into the DSL via +super+. A per-test policy call decides
+    # whether automatic screenshots are taken (see Capybara::Storyboard.policy).
+    module TestHelper
+      def self.included(base)
+        base.class_eval { before { __storyboard_init } }
+      end
+
+      # Manual screenshot hook. Captured only when enabled (like the automatic
+      # hooks); use Capybara's own save_screenshot for an unconditional shot.
+      def storyboard_screenshot(label)
+        @__storyboard.manual(page, label)
+      end
+
+      def visit(path, ...)
+        super.tap { @__storyboard.auto(page, 'visit', path) }
+      end
+
+      def click_on(locator = nil, ...)
+        @__storyboard.auto(page, 'before_click_on', locator)
+        super.tap { @__storyboard.auto(page, 'after_click_on', locator) }
+      end
+
+      def click_link(locator = nil, ...)
+        @__storyboard.auto(page, 'before_click_link', locator)
+        super.tap { @__storyboard.auto(page, 'after_click_link', locator) }
+      end
+
+      def click_button(locator = nil, ...)
+        @__storyboard.auto(page, 'before_click_button', locator)
+        super.tap { @__storyboard.auto(page, 'after_click_button', locator) }
+      end
+
+      def fill_in(locator, ...)
+        super.tap { @__storyboard.auto(page, 'fill_in', locator) }
+      end
+
+      def select(value = nil, ...)
+        super.tap { @__storyboard.auto(page, 'select', value) }
+      end
+
+      def check(locator, ...)
+        super.tap { @__storyboard.auto(page, 'check', locator) }
+      end
+
+      def uncheck(locator, ...)
+        super.tap { @__storyboard.auto(page, 'uncheck', locator) }
+      end
+
+      def choose(locator, ...)
+        super.tap { @__storyboard.auto(page, 'choose', locator) }
+      end
+
+      def attach_file(locator, ...)
+        super.tap { @__storyboard.auto(page, 'attach_file', locator) }
+      end
+
+      def accept_confirm(...)
+        @__storyboard.suppress_captures { super }.tap { @__storyboard.auto(page, 'accept_confirm') }
+      end
+
+      def accept_alert(...)
+        @__storyboard.suppress_captures { super }.tap { @__storyboard.auto(page, 'accept_alert') }
+      end
+
+      private
+
+      def __storyboard_init
+        example = RSpec.current_example
+        @__storyboard = Capybara::Storyboard::Session.new(
+          example:,
+          enabled: Capybara::Storyboard.policy.call(__storyboard_context(example))
+        )
+      end
+
+      # Derivation lives here so Context stays a plain value holder.
+      def __storyboard_context(example)
+        metadata = example.metadata
+        described = metadata[:described_class]
+        Capybara::Storyboard::Context.new(
+          test_class_name: described.respond_to?(:name) ? described.name : nil,
+          test_method_name: example.description,
+          test_file: metadata[:file_path]
+        )
+      end
+    end
+  end
+end

data/lib/capybara/storyboard/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Storyboard
+    VERSION = '0.1.0'
+  end
+end

data/lib/capybara/storyboard.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+require_relative 'storyboard/version'
+
+module Capybara
+  # Automatic Capybara screenshots for RSpec system specs, gated by a
+  # replaceable policy (see Capybara::Storyboard.policy).
+  module Storyboard
+    class Error < StandardError; end
+
+    class << self
+      # The single Configuration holding user overrides (output root, policy).
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      # Yields the Configuration for block-style setup:
+      #   Capybara::Storyboard.configure { |config| config.output_dir = ... }
+      def configure
+        yield(configuration)
+      end
+
+      # Drops every override (output_dir and policy) in one shot, restoring the
+      # gem's defaults. Handy in `after` hooks so a customized run never leaks
+      # into later examples.
+      def reset_configuration!
+        @configuration = nil
+      end
+
+      # Test-hygiene helper mirroring reset_configuration! / reset_policy!:
+      # clears the run-once flag so clear_output! can be exercised again
+      # within the same process (a real run never needs this).
+      def reset_output_cleared!
+        @output_cleared = nil
+      end
+
+      # Empties the output root once per process so a run's screenshots never mix
+      # with stale files left by a previous run. Meant to be wired into a
+      # before(:suite) hook by the host app (see the README); not called
+      # automatically, so nothing is registered on RSpec just by requiring the gem.
+      def clear_output!
+        # Run-once guard: idempotent even if the before(:suite) hook fires more
+        # than once (e.g. one hook per RSpec process under parallel_tests).
+        return if @output_cleared
+
+        # Arm gate: same bare-SCREENSHOTS probe as default_policy's own gate
+        # (EnvPolicy ignores its argument, so call(nil) is context-free). We
+        # deliberately do NOT use configuration.policy here: a custom policy
+        # assumes a per-example Context and may read the target list (raising
+        # when SCREENSHOT_TESTS_FILE is bad). A suite-wide clear must key off
+        # the global arm state alone, never per-example data.
+        return unless Policies::EnvPolicy.new.call(nil)
+
+        # Honor the run-once contract BEFORE touching the filesystem: if the
+        # delete fails, we must not keep retrying (and re-deleting) on later
+        # registrations of the same hook.
+        @output_cleared = true
+
+        # Resolve the root against the shared base so a relative output_dir
+        # (kept relative by Configuration) maps to a single absolute target.
+        root = configuration.output_dir.expand_path(rails_root_or_pwd)
+        return unless safe_to_clear?(root)
+        # First run / nothing captured yet: silently skip. Session#ensure_dir!
+        # lazily recreates the tree on the first capture, so a missing root is
+        # not an error.
+        return unless root.exist?
+
+        FileUtils.rm_rf(root)
+      end
+
+      # An object responding to #call(context) -> Boolean.
+      # Assign nil (or call reset_policy!) to restore the default.
+      # Delegated to the Configuration so there is a single source of truth.
+      def policy
+        configuration.policy
+      end
+
+      def policy=(value)
+        configuration.policy = value
+      end
+
+      # Equivalent to `self.policy = nil`; named for readable `after` hooks that
+      # prevent a custom policy from leaking into later examples.
+      def reset_policy!
+        configuration.reset_policy!
+      end
+
+      # Normalizes a test file path to a base-relative string so that target
+      # list entries and Context#test_file compare equal regardless of leading
+      # `./`, absolute vs relative form, or surrounding whitespace/newlines.
+      # Shared by default_policy (list side) and TargetListPolicy#call
+      # (context side) so both sides always agree on the canonical form.
+      def normalize_test_path(path)
+        base = rails_root_or_pwd
+        Pathname(path.to_s.strip)
+          .expand_path(base)
+          .relative_path_from(base)
+          .to_s
+      end
+
+      # The single place that resolves the base directory: Rails.root when
+      # available (the gem stays Rails-optional), else the current directory.
+      # Session#default_output_root joins its own subpath onto this.
+      def rails_root_or_pwd
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root
+        else
+          Pathname(Dir.pwd)
+        end
+      end
+
+      # The single place that builds the default policy. Internal API, public
+      # only so Configuration#policy can call it without `send`; use `policy`.
+      #
+      # When SCREENSHOTS is unset the mechanism is disarmed: return EnvPolicy
+      # alone WITHOUT touching the target list. This honors the "disabled ->
+      # nothing happens" contract even when SCREENSHOT_TESTS_FILE points at a
+      # missing file (its existence check must not blow up a disarmed suite).
+      #
+      # When armed: no target list configured (neither ENV set) -> EnvPolicy
+      # alone, preserving the gist's "SCREENSHOTS=1 captures everything". A
+      # target list configured (even an empty file) -> EnvPolicy AND
+      # TargetListPolicy; an empty set then means "explicitly zero targets".
+      def default_policy
+        env = Policies::EnvPolicy.new
+        # env.call(nil) probes the bare SCREENSHOTS switch (same gate
+        # clear_output! uses), inlined here so we can reuse this exact `env`
+        # instance as the return value below instead of building a second one.
+        # Disarmed -> skip reading/validating the target list entirely.
+        return env unless env.call(nil)
+
+        raw_targets = raw_target_list
+        return env if raw_targets.nil?
+
+        # Drop blank entries BEFORE normalizing: an empty string normalizes to
+        # "." (the base dir), which is not blank and would leak into the set.
+        targets = raw_targets.map { |path| path.to_s.strip }.compact_blank.map { |path| normalize_test_path(path) }
+        target = Policies::TargetListPolicy.new(targets)
+
+        # Composition style: a plain lambda. A proc responds to #call, so it
+        # satisfies the #call(context) -> Boolean policy contract, and it can
+        # still be replaced wholesale via #policy=.
+        ->(context) { env.call(context) && target.call(context) }
+      end
+
+      private
+
+      # Minimal foot-gun guard for the suite-wide clear: refuse the obviously
+      # dangerous roots (a filesystem root, or the project/cwd root itself)
+      # rather than rm_rf-ing them. Mirrors the "safe no-op + warn" convention
+      # used elsewhere (see Session#save_screenshot_safely); we deliberately
+      # stop at these two cases rather than attempting broad path sanitizing.
+      def safe_to_clear?(root)
+        if root.parent == root || root == rails_root_or_pwd
+          warn("capybara-storyboard: refusing to clear unsafe output root: #{root}")
+          return false
+        end
+
+        true
+      end
+
+      # Returns the raw (un-normalized) target list, or nil when no target list
+      # is configured at all. SCREENSHOT_TESTS_FILE and SCREENSHOT_TESTS are
+      # unioned when both are present.
+      def raw_target_list
+        file_entries = raw_target_list_from_file
+        inline_entries = raw_target_list_inline
+        return nil if file_entries.nil? && inline_entries.nil?
+
+        (file_entries || []) + (inline_entries || [])
+      end
+
+      # Reads SCREENSHOT_TESTS_FILE. Returns nil when unset/blank, raises when
+      # the path is set but missing (a silent all/none capture would be worse
+      # than a loud failure), otherwise the newline-split contents.
+      def raw_target_list_from_file
+        path = ENV.fetch('SCREENSHOT_TESTS_FILE', nil)
+        return nil unless path.present?
+
+        raise Error, "SCREENSHOT_TESTS_FILE does not exist: #{path}" unless File.exist?(path)
+
+        File.read(path).split("\n")
+      end
+
+      # Reads SCREENSHOT_TESTS. Returns nil when unset/blank, otherwise the
+      # comma-split entries.
+      def raw_target_list_inline
+        value = ENV.fetch('SCREENSHOT_TESTS', nil)
+        return nil unless value.present?
+
+        value.split(',')
+      end
+    end
+  end
+end
+
+require_relative 'storyboard/context'
+require_relative 'storyboard/policies/env_policy'
+require_relative 'storyboard/policies/target_list_policy'
+require_relative 'storyboard/configuration'
+require_relative 'storyboard/page_stability'
+require_relative 'storyboard/session'
+require_relative 'storyboard/test_helper'

data/sig/capybara/storyboard.rbs

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

data/skills/capybara-storyboard/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: capybara-storyboard
+description: Visually verify UI changes by running system specs with capybara-storyboard and reading the captured screenshot sequence. Use whenever app/views or app/components changes need a visual check, or when a system spec is changed and run.
+model: sonnet
+---
+
+# Capybara Storyboard visual review
+
+Capybara::Storyboard captures a Capybara operation (`visit`, `click_on`, ...) together with a
+screenshot at each step of a system spec, and lays the screenshots out as an ordered sequence
+per test. This skill drives an agent through generating and reading that sequence to catch
+things a passing test can't: layout breakage, leftover UI state (a modal that didn't close, a
+flash message still showing), error screens, or anything else that looks wrong for the action
+and point in the test where it occurs.
+
+Reviewing screenshots one image at a time only works if the set stays small — narrow to the
+system specs actually touched by the change, not the whole suite. Capturing every system spec
+would produce hundreds of images, which defeats the purpose.
+
+## When this applies
+
+- `app/views` or `app/components` were changed and the resulting screen needs a visual check.
+- A system spec was changed and is being run.
+
+## Steps
+
+### 1. Determine the target specs
+
+Narrow to the system specs relevant to the change:
+
+- If `app/views` or `app/components` changed, identify which system specs exercise the changed
+  screen(s) — search for the view/component name, the controller action, or the route it
+  belongs to. Use this bullet whenever the call sites are countable: if you can enumerate all
+  the places the changed view/component is used and there are roughly 10 or fewer, target those
+  specific call sites directly — even if the changed file is itself called a shared "component".
+  If more than one spec is a plausible match and it isn't obvious which apply, ask the user.
+- If enumerating every call site is impractical, or the changed file is a layout or
+  partial/component rendered by most/all pages rather than a handful of named places (so the
+  search above would return most or all system specs, not a short list), don't try to enumerate
+  every caller. Instead propose a small representative sample (roughly 3-6 specs) spanning
+  distinct usage contexts where the change is most likely to visually clash — e.g. a signed-out
+  page, a standard authenticated page, an admin/dense-UI page, a mobile/narrow-viewport spec if
+  one exists — and confirm the sample with the user before running, since you can't be sure
+  those spec files exist or still match without checking.
+- If a system spec itself was changed, that spec is the target.
+
+### 2. Run the specs and capture screenshots
+
+Run the target specs locally with only `SCREENSHOTS=1` set, passing the target spec files
+directly as `rspec` arguments so only the relevant tests produce screenshots:
+
+```bash
+SCREENSHOTS=1 bundle exec rspec spec/system/login_spec.rb spec/system/signup_spec.rb
+```
+
+Running `bundle exec rspec` with `SCREENSHOTS=1` and no spec path arguments captures **every**
+system spec — avoid this unless the user explicitly wants a full-suite review, since it
+produces an impractically large set of images to read one at a time.
+
+### 3. Enumerate the output
+
+Screenshots land at:
+
+```
+tmp/screenshots/{GroupName}/{example_name}/{NNN_action_detail}.png
+```
+
+Each `{GroupName}/{example_name}` directory is one system spec example — treat it as one unit
+of review. Within a directory, list PNGs in ascending `NNN` order: that zero-padded prefix is
+the order the actions happened during the test, and the rest of the filename names the action
+(e.g. `001_visit_users.png`, `002_before_click_on_Done.png`,
+`003_after_click_on_Done.png`). Click methods (`click_on`, `click_link`, `click_button`)
+produce a before/after pair; everything else produces one screenshot taken after the action.
+
+### 4. Read each image in sequence
+
+For each `{GroupName}/{example_name}` directory, read its PNGs in `NNN` order, one at a time.
+For each image, use the filename (the action) and its position in the sequence (what happened
+right before it) to judge whether the screen looks right at that point — check for layout
+breakage, unintended or leftover UI state, error pages, and anything else inconsistent with
+the action just performed.
+
+### 5. Report per test
+
+For each `{GroupName}/{example_name}` directory report:
+
+- Which test it is.
+- For any issue found: which action/sequence number (by filename) it appeared right after,
+  and what was observed.
+
+A directory with no issues just needs a short confirmation — don't pad the report.
+
+### 6. Clean up
+
+Remove the local `tmp/screenshots/**` output once the review is done, unless the user wants it
+kept for later reference.

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: capybara-storyboard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- aki
+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: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Capybara::Storyboard records Capybara system test operations and their
+  screenshots, then visualizes them as a storyboard so you can review test flows at
+  a glance.
+email:
+- lala.akira@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- docs/github-actions.md
+- lib/capybara/storyboard.rb
+- lib/capybara/storyboard/configuration.rb
+- lib/capybara/storyboard/context.rb
+- lib/capybara/storyboard/page_stability.rb
+- lib/capybara/storyboard/policies/env_policy.rb
+- lib/capybara/storyboard/policies/target_list_policy.rb
+- lib/capybara/storyboard/session.rb
+- lib/capybara/storyboard/test_helper.rb
+- lib/capybara/storyboard/version.rb
+- sig/capybara/storyboard.rbs
+- skills/capybara-storyboard/SKILL.md
+homepage: https://github.com/aki77/capybara-storyboard
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/aki77/capybara-storyboard
+  source_code_uri: https://github.com/aki77/capybara-storyboard/tree/main
+  changelog_uri: https://github.com/aki77/capybara-storyboard/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.15
+specification_version: 4
+summary: Capture and visualize Capybara system test flows as screenshot storyboards.
+test_files: []