playwright-ruby-client 0.8.1 → 1.14.beta3

data/lib/playwright/{download.rb → download_impl.rb}

@@ -1,5 +1,5 @@
 module Playwright
-  class Download
+  define_api_implementation :DownloadImpl do
     def initialize(page:, url:, suggested_filename:, artifact:)
       @page = page
       @url = url

data/lib/playwright/javascript/expression.rb

@@ -24,13 +24,14 @@ module Playwright
         ::Playwright::ChannelOwner.from(resp)
       end
 
-      def eval_on_selector(channel, selector)
-        value = channel.send_message_to_server(
-          'evalOnSelector',
+      def eval_on_selector(channel, selector, strict: nil)
+        params = {
           selector: selector,
           expression: @expression,
           arg: @serialized_arg,
-        )
+        }
+        params[:strict] = strict if strict
+        value = channel.send_message_to_server('evalOnSelector', params)
         ValueParser.new(value).parse
       end
 

data/lib/playwright/locator_impl.rb

@@ -0,0 +1,314 @@
+module Playwright
+  define_api_implementation :LocatorImpl do
+    def initialize(frame:, timeout_settings:, selector:)
+      @frame = frame
+      @timeout_settings = timeout_settings
+      @selector = selector
+    end
+
+    def to_s
+      "Locator@#{@selector}"
+    end
+
+    private def with_element(timeout: nil, &block)
+      start_time = Time.now
+
+      handle = @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout)
+      unless handle
+        raise "Could not resolve #{@selector} to DOM Element"
+      end
+
+      call_options = {}
+      if timeout
+        call_options[:timeout] = (timeout - (Time.now - start_time) * 1000).to_i
+      end
+
+      begin
+        block.call(handle, call_options)
+      ensure
+        handle.dispose
+      end
+    end
+
+    def bounding_box(timeout: nil)
+      with_element(timeout: timeout) do |handle|
+        handle.bounding_box
+      end
+    end
+
+    def check(
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+
+      @frame.check(@selector,
+        strict: true,
+        force: force,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def click(
+          button: nil,
+          clickCount: nil,
+          delay: nil,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+
+      @frame.click(@selector,
+        strict: true,
+        button: button,
+        clickCount: clickCount,
+        delay: delay,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def dblclick(
+          button: nil,
+          delay: nil,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+
+      @frame.dblclick(@selector,
+        strict: true,
+        button: button,
+        delay: delay,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def dispatch_event(type, eventInit: nil, timeout: nil)
+      @frame.dispatch_event(@selector, type, strict: true, eventInit: eventInit, timeout: timeout)
+    end
+
+    def evaluate(expression, arg: nil, timeout: nil)
+      with_element(timeout: timeout) do |handle|
+        handle.evaluate(expression, arg: arg)
+      end
+    end
+
+    def evaluate_all(expression, arg: nil)
+      @frame.eval_on_selector_all(@selector, expression, arg: arg)
+    end
+
+    def evaluate_handle(expression, arg: nil, timeout: nil)
+      with_element(timeout: timeout) do |handle|
+        handle.evaluate_handle(expression, arg: arg)
+      end
+    end
+
+    def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
+      @frame.fill(@selector, value, strict: true, force: force, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def locator(selector)
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> #{selector}",
+      )
+    end
+
+    def element_handle(timeout: nil)
+      @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout)
+    end
+
+    def element_handles
+      @frame.query_selector_all(@selector)
+    end
+
+    def first
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> nth=0",
+      )
+    end
+
+    def last
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> nth=-1",
+      )
+    end
+
+    def nth(index)
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> nth=#{index}",
+      )
+    end
+
+    def focus(timeout: nil)
+      @frame.focus(@selector, strict: true, timeout: timeout)
+    end
+
+    def count
+      @frame.eval_on_selector_all(@selector, 'ee => ee.length')
+    end
+
+    def get_attribute(name, timeout: nil)
+      @frame.get_attribute(@selector, name, strict: true, timeout: timeout)
+    end
+
+    def hover(
+          force: nil,
+          modifiers: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      @frame.hover(@selector,
+        strict: true,
+        force: force,
+        modifiers: modifiers,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def inner_html(timeout: nil)
+      @frame.inner_html(@selector, strict: true, timeout: timeout)
+    end
+
+    def inner_text(timeout: nil)
+      @frame.inner_text(@selector, strict: true, timeout: timeout)
+    end
+
+    def input_value(timeout: nil)
+      @frame.input_value(@selector, strict: true, timeout: timeout)
+    end
+
+    %i[checked? disabled? editable? enabled? hidden? visible?].each do |method_name|
+      define_method(method_name) do |timeout: nil|
+        @frame.public_send(method_name, @selector, strict: true, timeout: timeout)
+      end
+    end
+
+    def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
+      @frame.press(@selector, key, strict: true, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def screenshot(
+          omitBackground: nil,
+          path: nil,
+          quality: nil,
+          timeout: nil,
+          type: nil)
+      with_element(timeout: timeout) do |handle, options|
+        handle.screenshot(
+          omitBackground: omitBackground,
+          path: path,
+          quality: quality,
+          timeout: options[:timeout],
+          type: type)
+      end
+    end
+
+    def scroll_into_view_if_needed(timeout: nil)
+      with_element(timeout: timeout) do |handle, options|
+        handle.scroll_into_view_if_needed(timeout: options[:timeout])
+      end
+    end
+
+    def select_option(
+          element: nil,
+          index: nil,
+          value: nil,
+          label: nil,
+          force: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+
+      @frame.select_option(@selector,
+        strict: true,
+        element: element,
+        index: index,
+        value: value,
+        label: label,
+        force: force,
+        noWaitAfter: noWaitAfter,
+        timeout: timeout)
+    end
+
+    def select_text(force: nil, timeout: nil)
+      with_element(timeout: timeout) do |handle, options|
+        handle.select_text(force: force, timeout: options[:timeout])
+      end
+    end
+
+    def set_input_files(files, noWaitAfter: nil, timeout: nil)
+      @frame.set_input_files(@selector, files, strict: true, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def tap_point(
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      @frame.tap_point(@selector,
+        strict: true,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def text_content(timeout: nil)
+      @frame.text_content(@selector, strict: true, timeout: timeout)
+    end
+
+    def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      @frame.type(@selector, text, strict: true, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def uncheck(
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      @frame.uncheck(@selector,
+        strict: true,
+        force: force,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def all_inner_texts
+      @frame.eval_on_selector_all(@selector, 'ee => ee.map(e => e.innerText)')
+    end
+
+    def all_text_contents
+      @frame.eval_on_selector_all(@selector, "ee => ee.map(e => e.textContent || '')")
+    end
+  end
+end

data/lib/playwright/timeout_settings.rb

@@ -8,12 +8,12 @@ module Playwright
 
     attr_writer :default_timeout, :default_navigation_timeout
 
-    def navigation_timeout
-      @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
+    def navigation_timeout(timeout_override = nil)
+      timeout_override || @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
     end
 
-    def timeout
-      @default_timeout || @parent&.timeout || DEFAULT_TIMEOUT
+    def timeout(timeout_override = nil)
+      timeout_override || @default_timeout || @parent&.timeout || DEFAULT_TIMEOUT
     end
   end
 end

data/lib/playwright/touchscreen_impl.rb

@@ -3,5 +3,12 @@ module Playwright
     def initialize(channel)
       @channel = channel
     end
+
+    def tap_point(x, y)
+      @channel.send_message_to_server('touchscreenTap', {
+        x: x,
+        y: y,
+      })
+    end
   end
 end

data/lib/playwright/tracing_impl.rb

@@ -16,16 +16,17 @@ module Playwright
 
     # Stop tracing.
     def stop(path: nil)
+      export(path: path) if path
       @channel.send_message_to_server('tracingStop')
+    end
 
-      if path
-        resp = @channel.send_message_to_server('tracingExport')
-        artifact = ChannelOwners::Artifact.from(resp)
-        # if self._context._browser:
-        #   artifact._is_remote = self._context._browser._is_remote
-        artifact.save_as(path)
-        artifact.delete
-      end
+    private def export(path:)
+      resp = @channel.send_message_to_server('tracingExport')
+      artifact = ChannelOwners::Artifact.from(resp)
+      # if self._context._browser:
+      #   artifact._is_remote = self._context._browser._is_remote
+      artifact.save_as(path)
+      artifact.delete
     end
   end
 end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.8.1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.13.0'
+  VERSION = '1.14.beta3'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.14.0'
 end

data/lib/playwright_api/accessibility.rb

@@ -44,7 +44,7 @@ module Playwright
     #     print(node["name"])
     # ```
     def snapshot(interestingOnly: nil, root: nil)
-      raise NotImplementedError.new('snapshot is not implemented yet.')
+      wrap_impl(@impl.snapshot(interestingOnly: unwrap_impl(interestingOnly), root: unwrap_impl(root)))
     end
   end
 end

data/lib/playwright_api/android.rb

@@ -1,6 +1,19 @@
 module Playwright
-  # Playwright has **experimental** support for Android automation. See [here](./mobile.md) for more information. You can
-  # access android namespace via:
+  # Playwright has **experimental** support for Android automation. This includes Chrome for Android and Android WebView.
+  #
+  # *Requirements*
+  # - Android device or AVD Emulator.
+  # - [ADB daemon](https://developer.android.com/studio/command-line/adb) running and authenticated with your device.
+  #   Typically running `adb devices` is all you need to do.
+  # - [`Chrome 87`](https://play.google.com/store/apps/details?id=com.android.chrome) or newer installed on the device
+  # - "Enable command line on non-rooted devices" enabled in `chrome://flags`.
+  #
+  # *Known limitations*
+  # - Raw USB operation is not yet supported, so you need ADB.
+  # - Device needs to be awake to produce screenshots. Enabling "Stay awake" developer mode will help.
+  # - We didn't run all the tests against the device, so not everything works.
+  #
+  # *How to run*
   #
   # An example of the Android automation script would be:
   #
@@ -23,12 +36,6 @@ module Playwright
     end
     alias_method :default_timeout=, :set_default_timeout
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
@@ -41,6 +48,12 @@ module Playwright
       event_emitter_proxy.on(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end