capybara-playwright-driver 0.5.8 → 0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe14f82e64d08efc962dda883c9c4a6b54b794c75bb5458c522fbf88e839267a
-  data.tar.gz: 59156f6e1a5db3dd787b1342cafd5c9f8aca74df33042013304cdd029875e64c
+  metadata.gz: a9766817ce50a7580acf4f72c062780da5a2363ea838dea3a8f17207c359c144
+  data.tar.gz: 5b48eb5b0eb4145088457e8b0c1a26c5843f80dc3e3d9acf120c095fd2d7691a
 SHA512:
-  metadata.gz: 3bbf39026f4bc9dfdce2c319510c709e00b6eb5a890e8057566f57a2b804e2890ff3ee97d67a8ba5da3fe7ede58c526f4b239cd425fe6ac47f049075a83a0a7d
-  data.tar.gz: 813ccb3ce551cb1a3484d261096d8847d045cd694b6dc8275ba27f4012fab798ed23ad2bf36f2996818b653bf6ed4d0213d8f7c9f131cccf1c242450ea86327c
+  metadata.gz: d7b079c7c184643a16cfae94e7aaafd325460a3a13e3ece9cf453b127045a44a8ea008b29b65c326325ad3cbb7b3a8f092ff325267df512ac3f1645565ef6baa
+  data.tar.gz: 46290aabe5623d54094efa2cd30369261ca32525b99835e0f6e393ddc48de3e9d1e21011e64cd61dfd00531bf05818dab69525c1cb450f9f2d46679b9c19b0c5

data/AGENTS.md

@@ -0,0 +1,115 @@
+# AGENTS.md
+
+## Ruby Style
+- This repository is Ruby-first. Prefer Ruby naming and control flow over Python- or Java-style ceremony.
+- Use names that describe the role in the domain. Avoid vague plumbing names like `context`, `handler`, `data`, or `control` unless they are the clearest possible name.
+- Boolean-returning methods must end with `?`.
+- Prefer `find`, `any?`, early return, and guard clauses over `value = nil` plus later reassignment.
+- Do not add `attr_reader` for every instance variable in a small internal object. If the state is only used internally, access the instance variable directly.
+- If an object is already scoped to one responsibility, avoid redundant prefixes in every private method name.
+- Do not prefix Ruby private methods with `_`. Use `private` for visibility and a normal method name for intent.
+
+## Naming Examples
+
+Bad:
+
+```ruby
+def _playwright_try_get_by_label(locator)
+  # ...
+end
+```
+
+Good:
+
+```ruby
+def find_by_label(locator)
+  # ...
+end
+```
+
+Bad:
+
+```ruby
+def click_associated_label(control)
+  return true if control.evaluate("el => !!el.checked")
+end
+```
+
+Good:
+
+```ruby
+def click_associated_label?(playwright_locator)
+  return true if playwright_locator.evaluate("el => !!el.checked")
+end
+```
+
+Bad:
+
+```ruby
+def initialize(node_context:, selector:, locator:, checked:)
+  @node_context = node_context
+  @selector = selector
+  @locator = locator
+  @checked = checked
+end
+```
+
+Good:
+
+```ruby
+def initialize(node:, node_type:, locator:, checked:)
+  @node = node
+  @node_type = node_type
+  @locator = locator
+  @checked = checked
+end
+```
+
+Bad:
+
+```ruby
+control = nil
+
+candidates.each do |candidate|
+  next unless matches?(candidate)
+
+  control = candidate
+  break
+end
+
+control
+```
+
+Good:
+
+```ruby
+candidates.find do |element_handle|
+  matches?(element_handle)
+end
+```
+
+Bad:
+
+```ruby
+attr_reader :node, :node_type, :locator, :checked
+```
+
+Good:
+
+```ruby
+def click_associated_label?(playwright_locator)
+  return true if playwright_locator.evaluate("el => !!el.checked") == @checked
+end
+```
+
+## General Guidance
+- Prefer concise Ruby that reads top-to-bottom without carrying unnecessary temporary state.
+- Prefer small private helper objects only when they reduce complexity. Once extracted, give them Ruby-like method names and keep their public surface minimal.
+
+## How to execute RSpec or Ruby
+
+`ruby` uses macOS system ruby interpreter (typically 2.6 or older). rbenv should be used.
+
+- Do not run the full `spec/capybara/playwright_spec.rb` or full RSpec suite locally; run broad coverage in GitHub Actions.
+- To run a focused Playwright compatibility check locally, use an example filter, for example:
+  `RBENV_VERSION=$(cat .ruby-version) ~/.rbenv/shims/bundle exec rspec spec/capybara/playwright_spec.rb --example fill_in`

data/Gemfile

@@ -15,6 +15,7 @@ gem 'rack-test_server'
 gem 'rake', '~> 13.0.3'
 gem 'rspec', '~> 3.11.0'
 gem 'rubocop-rspec'
+gem 'selenium-webdriver', '~> 4.34.0' if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.2')
 gem 'sinatra', '>= 1.4.0'
 gem 'webrick'
 gem 'websocket-driver'

data/lib/capybara/playwright/browser.rb

@@ -48,7 +48,7 @@ module Capybara
       private def create_page(browser_context)
         browser_context.new_page.tap do |page|
           page.on('close', -> {
-            if @playwright_page
+            if @playwright_page&.guid == page.guid
               @playwright_page = nil
             end
           })
@@ -89,10 +89,20 @@ module Capybara
         }
       end
 
+      private def firefox?
+        @playwright_browser.browser_type.name == 'firefox'
+      end
+
       def refresh
-        assert_page_alive {
+        if firefox?
+          # ref: https://github.com/microsoft/playwright/issues/39738
           @playwright_page.capybara_current_frame.evaluate('() => { location.reload(true) }')
-        }
+        else
+          assert_page_alive {
+            response = @playwright_page.reload
+            @playwright_page.capybara_set_last_response(response)
+          }
+        end
       end
 
       def find_xpath(query, **options)
@@ -255,7 +265,8 @@ module Capybara
           when /Element is not attached to the DOM/,
             /Execution context was destroyed, most likely because of a navigation/,
             /Cannot find context with specified id/,
-            /Unable to adopt element handle from a different document/
+            /Unable to adopt element handle from a different document/,
+            /maybe frame was detached/
             # ignore error for retry
             @internal_logger.warn(err.message)
           else
@@ -318,16 +329,35 @@ module Capybara
 
       def window_size(handle)
         on_window(handle) do |page|
-          page.evaluate('() => [window.innerWidth, window.innerHeight]')
+          outer_window_size(page)
         end
       end
 
       def resize_window_to(handle, width, height)
         on_window(handle) do |page|
-          page.viewport_size = { width: width, height: height }
+          page.viewport_size = viewport_size_for(page, width, height)
         end
       end
 
+      # Capybara follows Selenium's outer window size semantics.
+      private def outer_window_size(page)
+        page.evaluate('() => [window.outerWidth || window.innerWidth, window.outerHeight || window.innerHeight]')
+      end
+
+      private def viewport_size_for(page, width, height)
+        inset_width, inset_height = page.evaluate(<<~JAVASCRIPT)
+          () => [
+            Math.max(0, (window.outerWidth || window.innerWidth) - window.innerWidth),
+            Math.max(0, (window.outerHeight || window.innerHeight) - window.innerHeight)
+          ]
+        JAVASCRIPT
+
+        {
+          width: [width - inset_width, 0].max,
+          height: [height - inset_height, 0].max
+        }
+      end
+
       def maximize_window(handle)
         @internal_logger.warn("maximize_window is not supported in Playwright driver")
         # incomplete in Playwright

data/lib/capybara/playwright/node.rb

@@ -31,30 +31,127 @@ module Capybara
   Node::Element.prepend(WithElementHandlePatch)
 
   module NodeActionsAllowLabelClickPatch
+    class SelectableElementHandler
+      def initialize(node:, node_type:, locator:, checked:)
+        @node = node
+        @node_type = node_type
+        @locator = locator
+        @checked = checked
+      end
+
+      def set_checked_state_via_label?
+        playwright_checkable = find_playwright_element_handle_by_non_label_locator
+        playwright_checkable ||= playwright_locator_by_label unless @locator.nil?
+        return false unless playwright_checkable
+
+        click_associated_label?(playwright_checkable)
+      rescue Capybara::ElementNotFound, Capybara::ExpectationNotMet, ::Playwright::Error
+        false
+      end
+
+      private
+
+      def playwright_locator_by_label
+        driver.with_playwright_page do |playwright_page|
+          return playwright_page.get_by_label(@locator.to_s)
+        end
+      end
+
+      def click_associated_label?(playwright_element_handle_or_locator)
+        return true if playwright_element_handle_or_locator.evaluate('el => !!el.checked') == @checked
+
+        label_element_handle = playwright_element_handle_or_locator.evaluate_handle('(el) => (el.labels && el.labels[0]) || el.closest("label") || null')
+        return false unless label_element_handle.is_a?(::Playwright::ElementHandle)
+
+        label_element_handle.click
+
+        playwright_element_handle_or_locator.evaluate('el => !!el.checked') == @checked
+      end
+
+      def find_playwright_element_handle_by_non_label_locator
+        return nil if @locator.nil?
+
+        locator_string = @locator.to_s
+        test_id_attr = session_options.test_id&.to_s
+
+        driver.with_playwright_page do |playwright_page|
+          return non_label_playwright_element_handle_candidates(playwright_page).find do |element_handle|
+            attribute_values = element_handle.evaluate(<<~JAVASCRIPT, arg: test_id_attr)
+            (el, testIdAttr) => ({
+              id: el.id || '',
+              name: el.getAttribute('name') || '',
+              testId: testIdAttr ? (el.getAttribute(testIdAttr) || '') : '',
+            })
+            JAVASCRIPT
+            [attribute_values['id'], attribute_values['name'], attribute_values['testId']].include?(locator_string)
+          end
+        end
+      rescue ::Playwright::Error
+        nil
+      end
+
+      def non_label_playwright_element_handle_candidates(playwright_page)
+        input_type =
+          case @node_type
+          when :checkbox
+            'checkbox'
+          when :radio_button
+            'radio'
+          else
+            return []
+          end
+
+        current_scope = scope_element
+        return current_scope.query_selector_all(%(input[type="#{input_type}"])) if current_scope
+
+        playwright_page.capybara_current_frame.query_selector_all(%(input[type="#{input_type}"]))
+      end
+
+      def scope_element
+        return nil unless @node.is_a?(Capybara::Node::Element)
+        return nil unless @node.send(:base).is_a?(Capybara::Playwright::Node)
+
+        @node.send(:base).send(:element)
+      end
+
+      def driver
+        @node.send(:driver)
+      end
+
+      def session_options
+        @node.send(:session_options)
+      end
+    end
+
     def choose(locator = nil, **options)
-      _playwright_check_via_get_by_label(locator, checked: true, **options) { super }
+      check_via_label_click(:radio_button, locator, checked: true, **options) { super }
     end
 
     def check(locator = nil, **options)
-      _playwright_check_via_get_by_label(locator, checked: true, **options) { super }
+      check_via_label_click(:checkbox, locator, checked: true, **options) { super }
     end
 
     def uncheck(locator = nil, **options)
-      _playwright_check_via_get_by_label(locator, checked: false, **options) { super }
+      check_via_label_click(:checkbox, locator, checked: false, **options) { super }
     end
 
-    private def _playwright_check_via_get_by_label(locator, checked:, allow_label_click: session_options.automatic_label_click, **options)
-      unless _playwright_use_get_by_label?(locator, allow_label_click, options)
+    private def check_via_label_click(node_type, locator, checked:, allow_label_click: session_options.automatic_label_click, **options)
+      unless should_use_label_click?(allow_label_click, options)
         return yield
       end
 
-      return self if _playwright_try_get_by_label(locator, checked: checked)
+      handler = SelectableElementHandler.new(
+        node: self,
+        node_type: node_type,
+        locator: locator,
+        checked: checked,
+      )
+      return self if handler.set_checked_state_via_label?
 
       yield
     end
 
-    private def _playwright_use_get_by_label?(locator, allow_label_click, options)
-      return false if locator.nil?
+    private def should_use_label_click?(allow_label_click, options)
       return false unless allow_label_click
       return false unless driver.is_a?(Capybara::Playwright::Driver)
       return false if Hash.try_convert(allow_label_click)
@@ -62,33 +159,6 @@ module Capybara
 
       true
     end
-
-    private def _playwright_try_get_by_label(locator, checked:)
-      handled = false
-      driver.with_playwright_page do |playwright_page|
-        begin
-          control_locator = playwright_page.get_by_label(locator.to_s)
-          control = control_locator
-
-          if control.evaluate('el => !!el.checked') != checked
-            label = control.evaluate_handle('(el) => (el.labels && el.labels[0]) || el.closest("label") || null')
-            next unless label.is_a?(::Playwright::ElementHandle)
-
-            label.click
-          end
-
-          next unless control.evaluate('el => !!el.checked') == checked
-
-          handled = true
-        rescue ::Playwright::Error
-          handled = false
-        end
-      end
-
-      handled
-    rescue StandardError
-      false
-    end
   end
   if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
     # Prepend to Node::Base instead of Node::Actions because Ruby < 3.1
@@ -128,6 +198,20 @@ module Capybara
   end
   ::Playwright::ElementHandle.prepend(CapybaraObscuredPatch)
 
+  # ref: https://github.com/teamcapybara/capybara/pull/2424
+  module ElementDropPathCompatPatch
+    def drop(*args)
+      options = args.map { |arg| arg.respond_to?(:to_path) ? arg.to_path : arg }
+      synchronize { base.drop(*options) }
+      self
+    end
+  end
+  if Gem::Version.new(Capybara::VERSION) < Gem::Version.new('3.34.0')
+    # Older Capybara returns early for Pathname arguments in Element#drop,
+    # so the driver implementation never runs.
+    Node::Element.prepend(ElementDropPathCompatPatch)
+  end
+
   module Playwright
     # Selector and checking methods are derived from twapole/apparition
     # Action methods (click, select_option, ...) uses playwright.
@@ -174,7 +258,7 @@ module Capybara
       end
 
       private def capybara_default_wait_time
-        Capybara.default_max_wait_time * 1100 # with 10% buffer for allowing overhead.
+        Capybara.default_max_wait_time.to_f * 1100 # with 10% buffer for allowing overhead.
       end
 
       class NotActionableError < StandardError ; end
@@ -315,18 +399,69 @@ module Capybara
 
       class TextInput < Settable
         def set(value, **options)
+          case options[:clear]
+          when :backspace
+            @element.press('End', timeout: @timeout)
+            existing_text = @element.evaluate('el => el.value')
+            existing_text.length.times { @element.press('Backspace', timeout: @timeout) }
+          when :none
+            @element.press('End', timeout: @timeout)
+          when Array
+            @internal_logger.warn "options { clear: #{options[:clear]} } is ignored"
+          end
+
           text = value.to_s
-          if text.end_with?("\n")
-            @element.fill(text[0...-1], timeout: @timeout)
+          if press_enter = text.end_with?("\r\n")
+            text = text[0...-2]
+          elsif press_enter = text.end_with?("\n")
+            text = text[0...-1]
+          end
+
+          set_text(text, append: options[:clear] == :none)
+
+          if press_enter
             @element.press('Enter', timeout: @timeout)
-          else
-            @element.fill(text, timeout: @timeout)
           end
         rescue ::Playwright::TimeoutError
           raise if @element.editable?
 
           @internal_logger.info("Node#set: element is not editable. #{@element}")
         end
+
+        private def set_text(text, append:)
+          # ElementHandle#type can refocus inherited contenteditable descendants and drop the input.
+          if @element.evaluate('el => el.isContentEditable') && !append
+            @element.fill(text, timeout: @timeout)
+            return
+          end
+
+          if text.include?("\t")
+            type_tab_separated_text(text, append: append)
+            return
+          end
+
+          grapheme_clusters = text.scan(/\X/)
+          fill_text = grapheme_clusters[0...-1].join
+          typed_text = grapheme_clusters[-1].to_s
+
+          if append
+            @element.type(fill_text, timeout: @timeout) unless fill_text.empty?
+          else
+            @element.fill(fill_text, timeout: @timeout)
+          end
+          @element.type(typed_text, timeout: @timeout) unless typed_text.empty?
+        end
+
+        private def type_tab_separated_text(text, append:)
+          head, *tail = text.split("\t", -1)
+          set_text(head, append: append)
+          keyboard = @element.owner_frame.page.keyboard
+
+          tail.each do |part|
+            keyboard.press('Tab')
+            keyboard.type(part) unless part.empty?
+          end
+        end
       end
 
       class FileUpload < Settable
@@ -782,8 +917,47 @@ module Capybara
         end
       end
 
+      ATTACH_FILE = <<~JAVASCRIPT
+        () => {
+          const input = document.createElement('INPUT');
+          input.type = 'file';
+          input.multiple = true;
+          input.style.display = 'none';
+          document.body.appendChild(input);
+          return input;
+        }
+      JAVASCRIPT
+
+      DROP_FILE = <<~JAVASCRIPT
+        (el, input) => {
+          const dt = new DataTransfer();
+          for (const file of input.files) { dt.items.add(file); }
+          input.remove();
+          el.dispatchEvent(new DragEvent('drop', {
+            cancelable: true, bubbles: true, dataTransfer: dt
+          }));
+        }
+      JAVASCRIPT
+
+      DROP_STRING = <<~JAVASCRIPT
+        (el, items) => {
+          const dt = new DataTransfer();
+          for (const item of items) { dt.items.add(item.data, item.type); }
+          el.dispatchEvent(new DragEvent('drop', {
+            cancelable: true, bubbles: true, dataTransfer: dt
+          }));
+        }
+      JAVASCRIPT
+
       def drop(*args)
-        raise NotImplementedError
+        if args.first.is_a?(String) || args.first.is_a?(Pathname)
+          input = @page.evaluate_handle(ATTACH_FILE)
+          input.as_element.set_input_files(args.map(&:to_s))
+          @element.evaluate(DROP_FILE, arg: input)
+        else
+          items = args.flat_map { |arg| arg.map { |(type, data)| { type: type, data: data } } }
+          @element.evaluate(DROP_STRING, arg: items)
+        end
       end
 
       def scroll_by(x, y)

data/lib/capybara/playwright/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Playwright
-    VERSION = '0.5.8'
+    VERSION = '0.5.10'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-playwright-driver
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.10
 platform: ruby
 authors:
 - YusukeIwaki
@@ -58,6 +58,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- AGENTS.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt