playwright-ruby-client 0.7.1 → 0.8.0

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.7.1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.12.0'
+  VERSION = '0.8.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.13.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

data/lib/playwright/web_socket_transport.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_transport.py
+  class WebSocketTransport
+    # @param ws_endpoint [String] EndpointURL of WebSocket
+    def initialize(ws_endpoint:)
+      @ws_endpoint = ws_endpoint
+      @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+    end
+
+    def on_message_received(&block)
+      @on_message = block
+    end
+
+    def on_driver_crashed(&block)
+      @on_driver_crashed = block
+    end
+
+    class AlreadyDisconnectedError < StandardError ; end
+
+    # @param message [Hash]
+    def send_message(message)
+      debug_send_message(message) if @debug
+      msg = JSON.dump(message)
+
+      @ws.send_text(msg)
+    rescue Errno::EPIPE, IOError
+      raise AlreadyDisconnectedError.new('send_message failed')
+    end
+
+    # Terminate playwright-cli driver.
+    def stop
+      return unless @ws
+
+      future = Concurrent::Promises.resolvable_future
+
+      @ws.on_close do
+        future.fulfill(nil)
+      end
+
+      begin
+        @ws.close
+      rescue EOFError => err
+        # ignore EOLError. The connection is already closed.
+        future.fulfill(err)
+      end
+
+      # Wait for closed actually.
+      future.value!
+    end
+
+    # Start `playwright-cli run-driver`
+    #
+    # @note This method blocks until playwright-cli exited. Consider using Thread or Future.
+    def async_run
+      ws = WebSocketClient.new(
+        url: @ws_endpoint,
+        max_payload_size: 256 * 1024 * 1024, # 256MB
+      )
+      promise = Concurrent::Promises.resolvable_future
+      ws.on_open do
+        promise.fulfill(ws)
+      end
+      ws.on_error do |error_message|
+        promise.reject(WebSocketClient::TransportError.new(error_message))
+      end
+
+      # Some messages can be sent just after start, before setting @ws.on_message
+      # So set this handler before ws.start.
+      ws.on_message do |data|
+        handle_on_message(data)
+      end
+
+      ws.start
+      @ws = promise.value!
+      @ws.on_error do |error|
+        puts "[WebSocketTransport] error: #{error}"
+        @on_driver_crashed&.call
+      end
+    rescue Errno::ECONNREFUSED => err
+      raise WebSocketClient::TransportError.new(err)
+    end
+
+    private
+
+    def handle_on_message(data)
+      obj = JSON.parse(data)
+
+      debug_recv_message(obj) if @debug
+      @on_message&.call(obj)
+    end
+
+    def debug_send_message(message)
+      puts "\x1b[33mSEND>\x1b[0m#{message}"
+    end
+
+    def debug_recv_message(message)
+      puts "\x1b[33mRECV>\x1b[0m#{message}"
+    end
+  end
+end

data/lib/playwright_api/android.rb

@@ -25,20 +25,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/android_device.rb

@@ -161,14 +161,20 @@ module Playwright
       raise NotImplementedError.new('web_views is not implemented yet.')
     end
 
+    # @nodoc
+    def tap_on(selector, duration: nil, timeout: nil)
+      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
+    end
+
     # @nodoc
     def tree
       wrap_impl(@impl.tree)
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def tap_on(selector, duration: nil, timeout: nil)
-      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
@@ -183,12 +189,6 @@ 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

data/lib/playwright_api/browser.rb

@@ -158,20 +158,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/browser_context.rb

@@ -384,20 +384,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/browser_type.rb

@@ -145,20 +145,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/cdp_session.rb

@@ -13,12 +13,12 @@ module Playwright
   #
   # ```python sync
   # client = page.context().new_cdp_session(page)
-  # client.send("animation.enable")
-  # client.on("animation.animation_created", lambda: print("animation created!"))
-  # response = client.send("animation.get_playback_rate")
-  # print("playback rate is " + response["playback_rate"])
-  # client.send("animation.set_playback_rate", {
-  #     playback_rate: response["playback_rate"] / 2
+  # client.send("Animation.enable")
+  # client.on("Animation.animationCreated", lambda: print("animation created!"))
+  # response = client.send("Animation.getPlaybackRate")
+  # print("playback rate is " + str(response["playbackRate"]))
+  # client.send("Animation.setPlaybackRate", {
+  #     playbackRate: response["playbackRate"] / 2
   # })
   # ```
   class CDPSession < PlaywrightApi
@@ -35,20 +35,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     private def event_emitter_proxy