capybara-playwright-driver 0.5.8 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe14f82e64d08efc962dda883c9c4a6b54b794c75bb5458c522fbf88e839267a
-  data.tar.gz: 59156f6e1a5db3dd787b1342cafd5c9f8aca74df33042013304cdd029875e64c
+  metadata.gz: a319465a40c53ac5b47d86ccd4d15136c20dcf7f6dde6fe17b3906d44cb2fd94
+  data.tar.gz: 1e38fb6020a87a07e6eaa8e997084b3abd98a0a8d5cbec4e92819a960c525f62
 SHA512:
-  metadata.gz: 3bbf39026f4bc9dfdce2c319510c709e00b6eb5a890e8057566f57a2b804e2890ff3ee97d67a8ba5da3fe7ede58c526f4b239cd425fe6ac47f049075a83a0a7d
-  data.tar.gz: 813ccb3ce551cb1a3484d261096d8847d045cd694b6dc8275ba27f4012fab798ed23ad2bf36f2996818b653bf6ed4d0213d8f7c9f131cccf1c242450ea86327c
+  metadata.gz: 5d1d8aeccb05f0c667c3b1a617cb1d2f19eb7fa096788a46b81985730f1a75b6ee7196ad952d2152c173b7401980090f738db399503b3ddceac097ced637678c
+  data.tar.gz: 141fd5024a9d322faf9031951e0f74a61426af350ed06d73017b2db90ec5b866e1af9b17edd5017e5c35f79f198cfa5916b220afcf621db9a2538c5fb50f443b

data/AGENTS.md

@@ -0,0 +1,107 @@
+# 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.

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
           })

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.
@@ -315,13 +399,31 @@ 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)
-            @element.press('Enter', timeout: @timeout)
+          if press_enter = text.end_with?("\n")
+            text = text[0...-1]
+          end
+
+          if options[:clear] == :none
+            @element.type(text, timeout: @timeout)
           else
             @element.fill(text, timeout: @timeout)
           end
+
+          if press_enter
+            @element.press('Enter', timeout: @timeout)
+          end
         rescue ::Playwright::TimeoutError
           raise if @element.editable?
 
@@ -782,8 +884,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.9'
   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.9
 platform: ruby
 authors:
 - YusukeIwaki
@@ -58,6 +58,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- AGENTS.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt