playwright-ruby-client 0.7.0 → 0.9.0

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=first",
+      )
+    end
+
+    def last
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> _nth=last",
+      )
+    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/route_handler_entry.rb

@@ -1,10 +1,11 @@
 module Playwright
   class RouteHandlerEntry
     # @param url [String]
+    # @param base_url [String|nil]
     # @param handler [Proc]
-    def initialize(url, handler)
+    def initialize(url, base_url, handler)
       @url_value = url
-      @url_matcher = UrlMatcher.new(url)
+      @url_matcher = UrlMatcher.new(url, base_url: base_url)
       @handler = handler
     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/transport.rb

@@ -8,7 +8,6 @@ module Playwright
   # ref: https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_transport.py
   class Transport
     # @param playwright_cli_executable_path [String] path to playwright-cli.
-    # @param debug [Boolean]
     def initialize(playwright_cli_executable_path:)
       @driver_executable_path = playwright_cli_executable_path
       @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'

data/lib/playwright/url_matcher.rb

@@ -1,19 +1,29 @@
 module Playwright
   class UrlMatcher
     # @param url [String|Regexp]
-    def initialize(url)
+    # @param base_url [String|nil]
+    def initialize(url, base_url:)
       @url = url
+      @base_url = base_url
     end
 
     def match?(target_url)
       case @url
       when String
-        @url == target_url || File.fnmatch?(@url, target_url)
+        joined_url == target_url || File.fnmatch?(@url, target_url)
       when Regexp
         @url.match?(target_url)
       else
         false
       end
     end
+
+    private def joined_url
+      if @base_url && !@url.start_with?('*')
+        URI.join(@base_url, @url).to_s
+      else
+        @url
+      end
+    end
   end
 end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.7.0'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.12.0'
+  VERSION = '0.9.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.14.0'
 end

data/lib/playwright/web_socket_client.rb

@@ -0,0 +1,164 @@
+require 'openssl'
+require 'socket'
+
+begin
+  require 'websocket/driver'
+rescue LoadError
+  raise "websocket-driver is required. Add `gem 'websocket-driver'` to your Gemfile"
+end
+
+# ref: https://github.com/rails/rails/blob/master/actioncable/lib/action_cable/connection/client_socket.rb
+# ref: https://github.com/cavalle/chrome_remote/blob/master/lib/chrome_remote/web_socket_client.rb
+module Playwright
+  class WebSocketClient
+    class SecureSocketFactory
+      def initialize(host, port)
+        @host = host
+        @port = port || 443
+      end
+
+      def create
+        tcp_socket = TCPSocket.new(@host, @port)
+        OpenSSL::SSL::SSLSocket.new(tcp_socket).tap(&:connect)
+      end
+    end
+
+    class DriverImpl # providing #url, #write(string)
+      def initialize(url)
+        @url = url
+
+        endpoint = URI.parse(url)
+        @socket =
+          if endpoint.scheme == 'wss'
+            SecureSocketFactory.new(endpoint.host, endpoint.port).create
+          else
+            TCPSocket.new(endpoint.host, endpoint.port)
+          end
+      end
+
+      attr_reader :url
+
+      def write(data)
+        @socket.write(data)
+      rescue Errno::EPIPE
+        raise EOFError.new('already closed')
+      rescue Errno::ECONNRESET
+        raise EOFError.new('closed by remote')
+      end
+
+      def readpartial(maxlen = 1024)
+        @socket.readpartial(maxlen)
+      rescue Errno::ECONNRESET
+        raise EOFError.new('closed by remote')
+      end
+
+      def disconnect
+        @socket.close
+      end
+    end
+
+    STATE_CONNECTING = 0
+    STATE_OPENED = 1
+    STATE_CLOSING = 2
+    STATE_CLOSED = 3
+
+    def initialize(url:, max_payload_size:)
+      @impl = DriverImpl.new(url)
+      @driver = ::WebSocket::Driver.client(@impl, max_length: max_payload_size)
+
+      setup
+    end
+
+    class TransportError < StandardError; end
+
+    private def setup
+      @ready_state = STATE_CONNECTING
+      @driver.on(:open) do
+        @ready_state = STATE_OPENED
+        handle_on_open
+      end
+      @driver.on(:close) do |event|
+        @ready_state = STATE_CLOSED
+        handle_on_close(reason: event.reason, code: event.code)
+      end
+      @driver.on(:error) do |event|
+        if !handle_on_error(error_message: event.message)
+          raise TransportError.new(event.message)
+        end
+      end
+      @driver.on(:message) do |event|
+        handle_on_message(event.data)
+      end
+    end
+
+    private def wait_for_data
+      @driver.parse(@impl.readpartial)
+    end
+
+    def start
+      @driver.start
+
+      Thread.new do
+        wait_for_data until @ready_state >= STATE_CLOSING
+      rescue EOFError
+        # Google Chrome was gone.
+        # We have nothing todo. Just finish polling.
+        if @ready_state < STATE_CLOSING
+          handle_on_close(reason: 'Going Away', code: 1001)
+        end
+      end
+    end
+
+    # @param message [String]
+    def send_text(message)
+      return if @ready_state >= STATE_CLOSING
+      @driver.text(message)
+    end
+
+    def close(code: 1000, reason: "")
+      return if @ready_state >= STATE_CLOSING
+      @ready_state = STATE_CLOSING
+      @driver.close(reason, code)
+    end
+
+    def on_open(&block)
+      @on_open = block
+    end
+
+    # @param block [Proc(reason: String, code: Numeric)]
+    def on_close(&block)
+      @on_close = block
+    end
+
+    # @param block [Proc(error_message: String)]
+    def on_error(&block)
+      @on_error = block
+    end
+
+    def on_message(&block)
+      @on_message = block
+    end
+
+    private def handle_on_open
+      @on_open&.call
+    end
+
+    private def handle_on_close(reason:, code:)
+      @on_close&.call(reason, code)
+      @impl.disconnect
+    end
+
+    private def handle_on_error(error_message:)
+      return false if @on_error.nil?
+
+      @on_error.call(error_message)
+      true
+    end
+
+    private def handle_on_message(data)
+      return if @ready_state != STATE_OPENED
+
+      @on_message&.call(data)
+    end
+  end
+end