capybara-dommy 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c7a62f13890b2fa82ad1270440924e9a1723a20975d71d91aa1bf24938922ae
+  data.tar.gz: 8045f008aaca496cab19488fc3b551cc2a955880d08bdc24034e60981d791ffe
+SHA512:
+  metadata.gz: e337cfa551b1a24a3f06554d5638260f5b2c2c19c09cad1b90aa3bfe55bd7363b1671f329070eabe32ab489ebcf035b06240cf79d1dea6ce364ff1541b2b9b03
+  data.tar.gz: 05ac1cd5fdda2ba28b907adbac630d3d139e2e33dfaf26f06478bd4fb7a7ca668b662fb4b6726da46818cae9aa09b5f95dc7a0390d81e9915bf64f1ad3ace1a0

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 0.8.0 — 2026-05-31
+
+Versioned in lockstep with [`dommy`](https://github.com/takahashim/dommy) 0.8.0.
+No functional changes to capybara-dommy itself.
+
+## 0.7.0 — 2026-05-30
+
+Initial release.
+
+Versioned in lockstep with the [`dommy`](https://github.com/takahashim/dommy)
+gem. capybara-dommy is a Capybara driver backed by `dommy` and `dommy-rack`. It
+drives Rack/Rails apps through the Capybara DSL without a real browser or
+JavaScript, keeping the page as a `Dommy::Document` (RackTest-like, with
+HTML-level visibility).

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Masayoshi Takahashi
+
+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,190 @@
+# Capybara::Dommy
+
+`capybara-dommy` is a [Capybara](https://github.com/teamcapybara/capybara) driver backed by
+[Dommy](https://github.com/takahashim/dommy) and `dommy-rack`.
+
+It drives Rack and Rails applications through the normal Capybara DSL without
+starting a real browser. The current page is kept as a `Dommy::Document`, so
+tests can inspect and interact with parsed HTML while staying close to the
+speed and simplicity of a Rack-style driver.
+
+## Features
+
+- Visits Rack endpoints without a browser process or JavaScript runtime.
+- Supports Capybara navigation, CSS/XPath queries, scoped `within` queries,
+  status codes, response headers, page title, and serialized HTML.
+- Supports common HTML interactions: links, buttons, form submission, text
+  fields, textareas, checkboxes, radios, selects, ranges, labels, details, and
+  file uploads.
+- Preserves session state such as cookies, follows redirects by default, and
+  supports browser-like back, forward, and refresh navigation.
+- Implements HTML-level visibility through `dommy-rack`.
+- Provides a Rails convenience require for `driven_by :dommy`.
+
+## Limitations
+
+`capybara-dommy` is intentionally not a browser automation driver.
+
+- JavaScript is not executed.
+- Screenshots, browser windows, alerts, confirms, prompts, and other real
+  browser features are not supported.
+- CSS layout is not calculated. Visibility is based on HTML-level rules such as
+  `hidden`, `type="hidden"`, and inline `display: none` handling provided by
+  `dommy-rack`.
+
+By default, `execute_script`, `evaluate_script`, and
+`evaluate_async_script` raise `Capybara::NotSupportedByDriverError`. You can
+turn those calls into no-ops with configuration when migrating tests that call
+JavaScript helpers incidentally.
+
+## Installation
+
+Add the gem to your application's Gemfile:
+
+```ruby
+gem "capybara-dommy"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Until the gem is available from RubyGems, install it from GitHub:
+
+```ruby
+gem "capybara-dommy", github: "takahashim/capybara-dommy"
+```
+
+`capybara-dommy` requires Ruby 3.2 or newer.
+
+## Usage
+
+For a plain Rack app, require the gem and register a Capybara driver:
+
+```ruby
+require "capybara/dommy"
+
+Capybara.register_driver(:dommy) do |app|
+  Capybara::Dommy::Driver.new(app)
+end
+
+Capybara.default_driver = :dommy
+```
+
+You can then use the normal Capybara DSL:
+
+```ruby
+visit "/"
+click_link "New post"
+fill_in "Title", with: "Hello"
+click_button "Create"
+
+expect(page).to have_text("Created")
+```
+
+### Rails System Tests
+
+For Rails system tests, require the Rails integration and use
+`driven_by :dommy`:
+
+```ruby
+# test/application_system_test_case.rb or spec/rails_helper.rb
+require "capybara/dommy/rails"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :dommy
+end
+```
+
+The Rails integration only registers the driver. Driver defaults still come from
+`Capybara::Dommy.configuration`.
+
+## Configuration
+
+Configure process-wide defaults before creating sessions:
+
+```ruby
+Capybara::Dommy.configure do |config|
+  config.default_host = "http://example.org"
+  config.follow_redirects = true
+  config.max_redirects = 5
+  config.visibility = :html
+  config.raise_on_unsupported_js = true
+end
+```
+
+Available options:
+
+- `default_host`: host used for relative visits. Defaults to
+  `"http://example.org"`.
+- `follow_redirects`: whether Rack redirects are followed automatically.
+  Defaults to `true`.
+- `max_redirects`: maximum redirect count. Defaults to `5`.
+- `visibility`: one of `:html`, `:all`, or `:none`. `:html` uses
+  `dommy-rack` visibility checks. `:all` and `:none` treat every element as
+  visible.
+- `raise_on_unsupported_js`: when `true`, JavaScript methods raise
+  `Capybara::NotSupportedByDriverError`; when `false`, they return `nil`.
+
+You can also override driver options per registration:
+
+```ruby
+Capybara.register_driver(:dommy) do |app|
+  Capybara::Dommy::Driver.new(
+    app,
+    default_host: "http://test.example",
+    follow_redirects: true,
+    max_redirects: 10,
+    visibility: :html
+  )
+end
+```
+
+## Development
+
+After checking out the repository, install dependencies:
+
+```bash
+bin/setup
+```
+
+Run the full test suite:
+
+```bash
+bundle exec rake spec
+```
+
+Run only the fast unit specs:
+
+```bash
+bundle exec rake spec:unit
+```
+
+Run only Capybara's shared driver compliance suite:
+
+```bash
+bundle exec rake spec:compliance
+```
+
+Open an interactive console:
+
+```bash
+bin/console
+```
+
+Install the gem locally:
+
+```bash
+bundle exec rake install
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub:
+<https://github.com/takahashim/capybara-dommy>.
+
+## License
+
+The gem is available as open source under the terms of the MIT License.

data/Rakefile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+# Everything (fast unit specs + Capybara compliance suite).
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+  desc "Run only the fast unit specs (no compliance harness / TestApp)"
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.pattern = "spec/unit/**/*_spec.rb"
+  end
+
+  desc "Run only the Capybara driver compliance suite"
+  RSpec::Core::RakeTask.new(:compliance) do |t|
+    t.pattern = "spec/compliance/**/*_spec.rb"
+  end
+end
+
+task default: :spec

data/lib/capybara/dommy/configuration.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Dommy
+    # Process-wide defaults for new drivers. `Driver.new` falls back to these
+    # when a keyword argument is omitted.
+    class Configuration
+      attr_accessor :default_host, :follow_redirects, :max_redirects, :visibility,
+                    :raise_on_unsupported_js
+
+      def initialize
+        @default_host = "http://example.org"
+        @follow_redirects = true
+        @max_redirects = 5
+        @visibility = :html
+        @raise_on_unsupported_js = true
+      end
+    end
+
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+    end
+  end
+end

data/lib/capybara/dommy/driver.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Dommy
+    # A Capybara driver backed by Dommy::Rack::Session. Implements the
+    # navigation / query / reset! parts of the Capybara::Driver::Base contract;
+    # element interaction lives in Capybara::Dommy::Node. JavaScript, screenshot,
+    # window, and modal methods are left to Driver::Base (which raises
+    # Capybara::NotSupportedByDriverError).
+    class Driver < Capybara::Driver::Base
+      VISIBILITY_MODES = %i[all html none].freeze
+
+      attr_reader :app, :visibility
+
+      def initialize(app,
+                     default_host: nil,
+                     follow_redirects: nil,
+                     max_redirects: nil,
+                     visibility: nil)
+        super()
+        config = Capybara::Dommy.configuration
+        @app = app
+        @visibility = visibility || config.visibility
+        unless VISIBILITY_MODES.include?(@visibility)
+          raise ArgumentError,
+                "unknown visibility mode #{@visibility.inspect} (expected one of #{VISIBILITY_MODES.join(", ")})"
+        end
+        @raise_on_unsupported_js = config.raise_on_unsupported_js
+        @session_options = {
+          default_host: default_host || config.default_host,
+          follow_redirects: follow_redirects.nil? ? config.follow_redirects : follow_redirects,
+          max_redirects: max_redirects || config.max_redirects,
+          # Capybara drives a trusted app and legitimately visits multiple
+          # hosts (e.g. app_host / multi-server specs), so don't enforce origin.
+          enforce_same_origin: false
+        }
+      end
+
+      # The dommy-rack session. Named `rack_session` to avoid colliding with
+      # Capybara::Driver::Base#session (the owning Capybara::Session). Rebuilt
+      # when the effective host (Capybara app_host / default_host) changes so
+      # current_url reflects it and same-origin checks pass.
+      def rack_session
+        host = effective_host
+        if @rack_session.nil? || @rack_session_host != host
+          @rack_session = ::Dommy::Rack::Session.new(@app, **@session_options.merge(default_host: host))
+          @rack_session_host = host
+        end
+        @rack_session
+      end
+
+      # --- Navigation ---
+
+      def visit(path)
+        # A fresh visit resolves a relative path against the host root (not the
+        # current page's directory), matching browser address-bar semantics.
+        rack_session.visit(::URI.join("#{effective_host}/", path.to_s).to_s)
+      rescue URI::InvalidURIError
+        rack_session.visit(path)
+      end
+
+      def current_url
+        rack_session.current_url.to_s
+      end
+
+      def refresh
+        rack_session.reload
+      end
+
+      def go_back
+        rack_session.back
+      end
+
+      def go_forward
+        rack_session.forward
+      end
+
+      # --- Page state ---
+
+      def html
+        rack_session.html
+      end
+
+      def title
+        document&.title
+      end
+
+      def status_code
+        rack_session.status
+      end
+
+      def response_headers
+        rack_session.headers || {}
+      end
+
+      # --- Query (returns Capybara::Dommy::Node arrays) ---
+
+      def find_css(query, **_options)
+        wrap(document&.query_selector_all(query))
+      end
+
+      def find_xpath(query, **_options)
+        wrap(document&.xpath(query))
+      end
+
+      # --- Node-facing seam (keeps the dommy-rack Session API in one place) ---
+
+      def document
+        rack_session.document
+      end
+
+      def follow_link(element)
+        rack_session.click_link_element(element)
+      end
+
+      def submit_form(form, submitter:)
+        rack_session.submit_form(form, submitter: submitter)
+      end
+
+      # --- Lifecycle ---
+
+      def reset!
+        @rack_session = nil
+      end
+
+      def wait?
+        false
+      end
+
+      def needs_server?
+        false
+      end
+
+      # Lets Capybara reload a node when it goes stale (after navigation).
+      def invalid_element_errors
+        [Capybara::Dommy::StaleElementReferenceError]
+      end
+
+      # --- JavaScript (unsupported) ---
+      # When raise_on_unsupported_js is false these become no-ops, so tests
+      # that incidentally call them don't fail.
+
+      def execute_script(_script, *_args)
+        unsupported_js!("execute_script")
+      end
+
+      def evaluate_script(_script, *_args)
+        unsupported_js!("evaluate_script")
+      end
+
+      def evaluate_async_script(_script, *_args)
+        unsupported_js!("evaluate_async_script")
+      end
+
+      # Visibility decision used by Node#visible?. :all / :none treat every
+      # element as visible; :html defers to dommy-rack's HTML-level check.
+      def visible?(element)
+        return true if @visibility == :all || @visibility == :none
+
+        ::Dommy::Rack.visible?(element)
+      end
+
+      private
+
+      # Capybara's app_host (set per-example) wins over default_host; falls
+      # back to the host this driver was configured with. Guarded so a
+      # standalone driver (no owning Capybara session) still works.
+      def effective_host
+        options = owning_session_options
+        (options && (options.app_host || options.default_host)) || @session_options[:default_host]
+      end
+
+      def owning_session_options
+        session_options if session
+      rescue StandardError
+        nil
+      end
+
+      def wrap(elements)
+        (elements || []).map { |element| Node.new(self, element) }
+      end
+
+      def unsupported_js!(name)
+        return nil unless @raise_on_unsupported_js
+
+        raise Capybara::NotSupportedByDriverError,
+              "capybara-dommy does not support JavaScript (#{name})"
+      end
+    end
+  end
+end

data/lib/capybara/dommy/errors.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Dommy
+    # Base error for capybara-dommy. Element lookup failures surface as
+    # Capybara's own ElementNotFound / Ambiguous from the finder layer, and
+    # unsupported-URL / cross-origin errors propagate from dommy-rack.
+    class Error < StandardError; end
+
+    # Raised when a node is used after its element left the current document
+    # (e.g. after navigation). Listed in Driver#invalid_element_errors so
+    # Capybara reloads and retries.
+    class StaleElementReferenceError < Error; end
+  end
+end

data/lib/capybara/dommy/node.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Dommy
+    # Wraps a Dommy::Element as a Capybara driver node. Modeled on
+    # Capybara::RackTest::Node: field setting mutates the Dommy::Element in the
+    # live document, while link clicks and form submission delegate to the
+    # dommy-rack session (which re-reads the same document at submit time).
+    class Node < Capybara::Driver::Node
+      OPTION_OWNER_XPATH = "./parent::*[self::optgroup | self::select | self::datalist]"
+      DISABLED_BY_FIELDSET_XPATH =
+        "./parent::fieldset[./@disabled] | " \
+        "./ancestor::*[(not(./self::legend) or ./preceding-sibling::legend)][./parent::fieldset[./@disabled]]"
+
+      def tag_name
+        native.tag_name.downcase
+      end
+
+      def [](name)
+        native.get_attribute(name.to_s)
+      end
+
+      def value
+        if select?
+          native.multiple ? native.selected_options.map(&:value) : native.value
+        elsif checkable?
+          native.has_attribute?("value") ? native.get_attribute("value") : "on"
+        elsif native.respond_to?(:value)
+          native.value
+        end
+      end
+
+      def all_text
+        text_extractor.all_text(native)
+      end
+
+      def visible_text
+        text_extractor.visible_text(native)
+      end
+
+      def visible?
+        driver.visible?(native)
+      end
+
+      def checked?
+        native.respond_to?(:checked) && native.checked
+      end
+
+      def selected?
+        native.respond_to?(:selected) && native.selected
+      end
+
+      # `disabled` only applies to form-associated elements; on anything else
+      # (e.g. a link that incorrectly carries the attribute) it has no effect.
+      DISABLEABLE_ELEMENTS = %w[button fieldset input optgroup option select textarea].freeze
+
+      def disabled?
+        return false unless DISABLEABLE_ELEMENTS.include?(tag_name)
+        return true if native.has_attribute?("disabled")
+
+        if %w[option optgroup].include?(tag_name)
+          owner = native.xpath(OPTION_OWNER_XPATH).first
+          owner ? self.class.new(driver, owner).disabled? : false
+        else
+          !native.xpath(DISABLED_BY_FIELDSET_XPATH).empty?
+        end
+      end
+
+      # readonly does not apply to these input types, so they are never
+      # readonly even if the attribute is present (matches RackTest).
+      NON_READONLY_TYPES = %w[hidden range color checkbox radio file submit image reset button].freeze
+
+      def readonly?
+        return false if input_field? && NON_READONLY_TYPES.include?(field_type)
+
+        native.has_attribute?("readonly")
+      end
+
+      def path
+        native.path
+      end
+
+      def style(_styles)
+        {}
+      end
+
+      # --- Interaction ---
+
+      def click(_keys = [], **_options)
+        if link?
+          click_link_node
+        elsif submits?
+          submit_owning_form
+        elsif checkable?
+          set(!checked?)
+        elsif tag_name == "label"
+          click_label
+        elsif (details = native.closest("details"))
+          toggle_details(details)
+        end
+      end
+
+      def set(value, **_options)
+        return if disabled? || readonly?
+
+        if radio?
+          set_radio
+        elsif checkbox?
+          set_checkbox(value)
+        elsif range?
+          set_range(value)
+        elsif file?
+          set_file(value)
+        elsif input_field? || textarea?
+          set_text_value(value)
+        end
+      end
+
+      def select_option
+        return if disabled?
+
+        select_el = select_node
+        deselect_all(select_el) unless select_el&.multiple
+        native.selected = true
+      end
+
+      def unselect_option
+        unless select_node&.multiple
+          raise Capybara::UnselectNotAllowed, "Cannot unselect option from a non-multiple select box"
+        end
+
+        native.selected = false
+      end
+
+      # --- Scoped queries (for `within`) ---
+
+      def find_css(locator, **_options)
+        native.query_selector_all(locator).map { |element| self.class.new(driver, element) }
+      end
+
+      def find_xpath(locator, **_options)
+        native.xpath(locator).map { |element| self.class.new(driver, element) }
+      end
+
+      # Guard every public method with a staleness check so Capybara can
+      # reload a node whose element left the current document (after
+      # navigation). Mirrors Capybara::RackTest::Node.
+      public_instance_methods(false).each do |meth_name|
+        alias_method "unchecked_#{meth_name}", meth_name
+        private "unchecked_#{meth_name}"
+
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{meth_name}(...)
+            stale_check
+            send(:"unchecked_#{meth_name}", ...)
+          end
+        RUBY
+      end
+
+      private
+
+      def stale_check
+        return if native.document.equal?(driver.document)
+
+        raise StaleElementReferenceError, "element is no longer attached to the document"
+      end
+
+      def submit_owning_form
+        form = form_for(native)
+        driver.submit_form(form, submitter: native) if form
+      end
+
+      # javascript: links are no-ops in Capybara (a policy decision); every
+      # other link delegates to dommy-rack, which handles fragment / same-page
+      # / blank-href semantics and raises on genuinely unsupported schemes.
+      def click_link_node
+        scheme = native.get_attribute("href").to_s.split(":", 2).first.to_s.downcase
+        return if scheme == "javascript"
+
+        driver.follow_link(native)
+      end
+
+      def text_extractor
+        TextExtractor.new(driver)
+      end
+
+      def toggle_details(details)
+        if details.has_attribute?("open")
+          details.remove_attribute("open")
+        else
+          details.set_attribute("open", "open")
+        end
+      end
+
+      def click_label
+        control = labelled_control
+        return unless control
+
+        node = self.class.new(driver, control)
+        node.set(!node.checked?) if node.send(:checkable?)
+      end
+
+      def labelled_control
+        for_id = native.get_attribute("for")
+        if for_id && !for_id.empty?
+          document.get_element_by_id(for_id)
+        else
+          native.query_selector("input, textarea, select")
+        end
+      end
+
+      def set_text_value(value)
+        string = value.to_s
+        if text_or_password? && attribute_present?("maxlength")
+          string = string[0, native.get_attribute("maxlength").to_i].to_s
+        end
+
+        # An <input> value ending in a newline submits a single-field form.
+        # There is no submitter button in this case.
+        form = single_field_form
+        if input_field? && string.end_with?("\n") && form
+          native.value = string.chomp
+          driver.submit_form(form, submitter: nil)
+        else
+          native.value = string
+        end
+      end
+
+      def single_field_form
+        form = form_for(native)
+        return nil unless form && form.query_selector_all("input, textarea").length == 1
+
+        form
+      end
+
+      def set_range(value)
+        min = (native.get_attribute("min") || 0).to_f
+        max = (native.get_attribute("max") || 100).to_f
+        step = (native.get_attribute("step") || 1).to_f
+        v = value.to_f.clamp(min, max)
+        v = (((v - min) / step).round * step) + min
+        v = v.clamp(min, max)
+        native.value = (v == v.to_i ? v.to_i : v).to_s
+      end
+
+      def attribute_present?(name)
+        value = native.get_attribute(name)
+        value && !value.empty?
+      end
+
+      # Reflect checked state on the attribute so node[:checked] and form
+      # submission both observe it (Dommy's `checked=` only sets the property).
+      def set_checkbox(value)
+        if value
+          native.set_attribute("checked", "checked")
+        else
+          native.remove_attribute("checked")
+        end
+      end
+
+      def set_radio
+        name = native.get_attribute("name")
+        scope = native.closest("form") || document
+        if name && scope
+          scope.query_selector_all("input[type='radio']").each do |radio|
+            radio.remove_attribute("checked") if radio.get_attribute("name") == name
+          end
+        end
+        native.set_attribute("checked", "checked")
+      end
+
+      def set_file(value)
+        files = Array(value).map do |path|
+          path = path.to_s
+          raise Capybara::FileNotFound, "cannot attach file, #{path} does not exist" unless ::File.exist?(path)
+
+          ::Dommy::File.new(
+            [::File.binread(path)], ::File.basename(path),
+            "type" => ::Dommy::Rack::FileUpload.mime_type_for(path)
+          )
+        end
+        native.__driver_set_files__(files)
+      end
+
+      def deselect_all(select_el)
+        return unless select_el
+
+        select_el.options.each { |option| option.selected = false }
+      end
+
+      def form_for(element)
+        form_id = element.get_attribute("form")
+        if form_id && !form_id.empty?
+          document.get_element_by_id(form_id)
+        else
+          element.closest("form")
+        end
+      end
+
+      def select_node
+        native.closest("select")
+      end
+
+      def document
+        driver.document
+      end
+
+      def field_type
+        native.respond_to?(:type) ? native.type : nil
+      end
+
+      def input_field? = tag_name == "input"
+      def textarea? = tag_name == "textarea"
+      def select? = tag_name == "select"
+      def radio? = input_field? && field_type == "radio"
+      def checkbox? = input_field? && field_type == "checkbox"
+      def range? = input_field? && field_type == "range"
+      def file? = input_field? && field_type == "file"
+      def text_or_password? = input_field? && %w[text password].include?(field_type)
+      def checkable? = radio? || checkbox?
+      def link? = tag_name == "a" && !native.get_attribute("href").nil?
+
+      def submits?
+        if input_field?
+          %w[submit image].include?(field_type)
+        elsif tag_name == "button"
+          field_type == "submit"
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/capybara/dommy/rails.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "capybara/dommy"
+
+# Thin convenience layer: registers the :dommy driver so Rails system tests
+# can use `driven_by :dommy`. Driver defaults come from
+# Capybara::Dommy.configuration.
+Capybara.register_driver(:dommy) do |app|
+  Capybara::Dommy::Driver.new(app)
+end

data/lib/capybara/dommy/text_extractor.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Dommy
+    # Extracts text from a Dommy subtree, reusing Capybara's own whitespace
+    # normalization so results match the matchers' expectations. `all_text` is
+    # the raw textContent; `visible_text` excludes element subtrees that are
+    # hidden under the driver's visibility mode or are non-rendered
+    # (script/style/head), and inserts breaks at block boundaries.
+    class TextExtractor
+      include Capybara::Node::WhitespaceNormalizer
+
+      BLOCK_ELEMENTS = %w[
+        p h1 h2 h3 h4 h5 h6 ol ul pre address blockquote dl div fieldset form hr noscript table
+      ].freeze
+      NON_DISPLAYED_ELEMENTS = %w[script style head title].freeze
+
+      def initialize(driver)
+        @driver = driver
+      end
+
+      def all_text(element)
+        normalize_spacing(element.text_content)
+      end
+
+      def visible_text(element)
+        return "" unless @driver.visible?(element)
+
+        normalize_visible_spacing(displayed_text(element))
+      end
+
+      private
+
+      def displayed_text(element)
+        element.child_nodes.map do |child|
+          if text_node?(child)
+            # Whitespace inside a text node (incl. newlines) collapses to
+            # spaces; only block boundaries introduce line breaks.
+            child.text_content.tr(SQUEEZED_SPACES, " ")
+          elsif element_node?(child)
+            next "" if non_displayed?(child) || !@driver.visible?(child)
+
+            inner = displayed_text(child)
+            block_element?(child) ? "\n#{inner}\n" : inner
+          else
+            ""
+          end
+        end.join
+      end
+
+      def non_displayed?(node)
+        NON_DISPLAYED_ELEMENTS.include?(node.tag_name.downcase)
+      end
+
+      def block_element?(node)
+        BLOCK_ELEMENTS.include?(node.tag_name.downcase)
+      end
+
+      def text_node?(node)
+        node.is_a?(::Dommy::TextNode)
+      end
+
+      def element_node?(node)
+        node.is_a?(::Dommy::Element)
+      end
+    end
+  end
+end

data/lib/capybara/dommy/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Dommy
+    VERSION = "0.8.0"
+  end
+end

data/lib/capybara/dommy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "capybara"
+require "dommy"
+require "dommy/rack"
+
+require_relative "dommy/version"
+require_relative "dommy/errors"
+require_relative "dommy/configuration"
+require_relative "dommy/text_extractor"
+require_relative "dommy/node"
+require_relative "dommy/driver"
+
+module Capybara
+  module Dommy
+  end
+end

data/sig/capybara/dommy.rbs

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

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: capybara-dommy
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- takahashim
+bindir: exe
+cert_chain: []
+date: 2026-05-31 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: dommy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: dommy-rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description: |
+  capybara-dommy is a Capybara driver backed by Dommy and dommy-rack. It drives
+  Rack/Rails apps through the Capybara DSL without a real browser or JavaScript,
+  keeping the page as a Dommy::Document. RackTest-like, with HTML-level visibility.
+email:
+- takahashimm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/capybara/dommy.rb
+- lib/capybara/dommy/configuration.rb
+- lib/capybara/dommy/driver.rb
+- lib/capybara/dommy/errors.rb
+- lib/capybara/dommy/node.rb
+- lib/capybara/dommy/rails.rb
+- lib/capybara/dommy/text_extractor.rb
+- lib/capybara/dommy/version.rb
+- sig/capybara/dommy.rbs
+homepage: https://github.com/takahashim/dommy
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/takahashim/dommy
+  source_code_uri: https://github.com/takahashim/dommy/tree/main/gems/capybara-dommy
+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: 3.6.2
+specification_version: 4
+summary: A Dommy-backed Capybara driver
+test_files: []