playwright-ruby-client 0.2.1 → 0.5.5

data/lib/playwright/channel_owners/route.rb

@@ -0,0 +1,78 @@
+require 'base64'
+require 'mime/types'
+
+module Playwright
+  define_channel_owner :Route do
+    def request
+      ChannelOwners::Request.from(@initializer['request'])
+    end
+
+    def abort(errorCode: nil)
+      params = { errorCode: errorCode }.compact
+      @channel.async_send_message_to_server('abort', params)
+    end
+
+    def fulfill(
+          body: nil,
+          contentType: nil,
+          headers: nil,
+          path: nil,
+          status: nil)
+      params = {
+        contentType: contentType,
+        status: status,
+      }.compact
+
+      length = 0
+      content =
+        if body
+          body
+        elsif path
+          File.read(path)
+        else
+          nil
+        end
+
+      param_headers = headers || {}
+      if contentType
+        param_headers['content-type'] = contentType
+      elsif path
+        param_headers['content-type'] = mime_type_for(path)
+      end
+
+      if content
+        if content.is_a?(String)
+          params[:body] = content
+          params[:isBase64] = false
+        else
+          params[:body] = Base64.strict_encode64(content)
+          params[:isBase64] = true
+        end
+        param_headers['content-length'] ||= content.length.to_s
+      end
+
+      params[:headers] = HttpHeaders.new(param_headers).as_serialized
+
+      @channel.async_send_message_to_server('fulfill', params)
+    end
+
+    def continue(headers: nil, method: nil, postData: nil, url: nil)
+      overrides = { url: url, method: method }.compact
+
+      if headers
+        overrides[:headers] = HttpHeaders.new(headers).as_serialized
+      end
+
+      if postData
+        overrides[:postData] = Base64.strict_encode64(postData)
+      end
+
+      @channel.async_send_message_to_server('continue', overrides)
+    end
+
+    private def mime_type_for(filepath)
+      mime_types = MIME::Types.type_for(filepath)
+      mime_types.first.to_s || 'application/octet-stream'
+    end
+  end
+end

data/lib/playwright/channel_owners/selectors.rb

@@ -1,4 +1,22 @@
 module Playwright
   # https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_selectors.py
-  define_channel_owner :Selectors
+  define_channel_owner :Selectors do
+    def register(name, contentScript: nil, path: nil, script: nil)
+      source =
+        if path
+          File.read(path)
+        elsif script
+          script
+        else
+          raise ArgumentError.new('Either path or script parameter must be specified')
+        end
+      params = { name: name, source: source }
+      if contentScript
+        params[:contentScript] = true
+      end
+      @channel.send_message_to_server('register', params)
+
+      nil
+    end
+  end
 end

data/lib/playwright/channel_owners/stream.rb

@@ -0,0 +1,15 @@
+require 'base64'
+
+module Playwright
+  define_channel_owner :Stream do
+    def save_as(path)
+      File.open(path, 'wb') do |f|
+        loop do
+          binary = @channel.send_message_to_server('read')
+          break if !binary || binary.length == 0
+          f.write(Base64.strict_decode64(binary))
+        end
+      end
+    end
+  end
+end

data/lib/playwright/connection.rb

@@ -12,6 +12,12 @@ module Playwright
       @transport.on_message_received do |message|
         dispatch(message)
       end
+      @transport.on_driver_crashed do
+        @callbacks.each_value do |callback|
+          callback.reject(::Playwright::DriverCrashedError.new)
+        end
+        raise ::Playwright::DriverCrashedError.new
+      end
 
       @objects = {} # Hash[ guid => ChannelOwner ]
       @waiting_for_object = {} # Hash[ guid => Promise<ChannelOwner> ]
@@ -19,26 +25,22 @@ module Playwright
       @root_object = RootChannelOwner.new(self)
     end
 
-    def run
-      @transport.run
+    def async_run
+      @transport.async_run
     end
 
     def stop
       @transport.stop
     end
 
-    def async_wait_for_object_with_known_name(guid)
+    def wait_for_object_with_known_name(guid)
       if @objects[guid]
         return @objects[guid]
       end
 
       callback = Concurrent::Promises.resolvable_future
       @waiting_for_object[guid] = callback
-      callback
-    end
-
-    def wait_for_object_with_known_name(guid)
-      async_wait_for_object_with_known_name.value!
+      callback.value!
     end
 
     def async_send_message_to_server(guid, method, params)
@@ -195,32 +197,9 @@ module Playwright
       end
       initializer = replace_guids_with_channels(initializer)
 
-      class_name = case type
-      when 'Browser'
-        case initializer['name']
-        when 'chromium'
-          'ChromiumBrowser'
-        when 'webkit'
-          'WebKitBrowser'
-        when 'firefox'
-          'FirefoxBrowser'
-        else
-          'Browser'
-        end
-      when 'BrowserContext'
-        browser_name = initializer['browserName']
-        if browser_name == 'chromium'
-          'ChromiumBrowserContext'
-        else
-          'BrowserContext'
-        end
-      else
-        type
-      end
-
       result =
         begin
-          ChannelOwners.const_get(class_name).new(
+          ChannelOwners.const_get(type).new(
             parent,
             type,
             guid,

data/lib/playwright/download.rb

@@ -0,0 +1,27 @@
+module Playwright
+  class Download
+    def initialize(url:, suggested_filename:, artifact:)
+      @url = url
+      @suggested_filename = suggested_filename
+      @artifact = artifact
+    end
+
+    attr_reader :url, :suggested_filename
+
+    def delete
+      @artifact.delete
+    end
+
+    def failure
+      @artifact.failure
+    end
+
+    def path
+      @artifact.path_after_finished
+    end
+
+    def save_as(path)
+      @artifact.save_as(path)
+    end
+  end
+end

data/lib/playwright/errors.rb

@@ -27,6 +27,12 @@ module Playwright
     end
   end
 
+  class DriverCrashedError < StandardError
+    def initialize
+      super("[BUG] Playwright driver is crashed!")
+    end
+  end
+
   class TimeoutError < Error
     def initialize(message:, stack: [])
       super(name: 'TimeoutError', message: message, stack: stack)

data/lib/playwright/events.rb

@@ -24,8 +24,10 @@ end
   },
 
   BrowserContext: {
+    BackgroundPage: 'backgroundpage',
     Close: 'close',
     Page: 'page',
+    ServiceWorker: 'serviceworker',
   },
 
   BrowserServer: {
@@ -67,11 +69,6 @@ end
     Close: 'close',
   },
 
-  ChromiumBrowserContext: {
-    BackgroundPage: 'backgroundpage',
-    ServiceWorker: 'serviceworker',
-  },
-
   ElectronApplication: {
     Close: 'close',
     Window: 'window',

data/lib/playwright/keyboard_impl.rb

@@ -10,7 +10,7 @@ module Playwright
     end
 
     def up(key)
-      @channel.send_message_to_server('keyboardDown', key: key)
+      @channel.send_message_to_server('keyboardUp', key: key)
     end
 
     def insert_text(text)

data/lib/playwright/mouse_impl.rb

@@ -3,5 +3,46 @@ module Playwright
     def initialize(channel)
       @channel = channel
     end
+
+    def move(x, y, steps: nil)
+      params = { x: x, y: y, steps: steps }.compact
+      @channel.send_message_to_server('mouseMove', params)
+      nil
+    end
+
+    def down(button: nil, clickCount: nil)
+      params = { button: button, clickCount: clickCount }.compact
+      @channel.send_message_to_server('mouseDown', params)
+      nil
+    end
+
+    def up(button: nil, clickCount: nil)
+      params = { button: button, clickCount: clickCount }.compact
+      @channel.send_message_to_server('mouseUp', params)
+      nil
+    end
+
+    def click(
+      x,
+      y,
+      button: nil,
+      clickCount: nil,
+      delay: nil)
+
+      params = {
+        x: x,
+        y: y,
+        button: button,
+        clickCount: clickCount,
+        delay: delay,
+      }.compact
+      @channel.send_message_to_server('mouseClick', params)
+
+      nil
+    end
+
+    def dblclick(x, y, button: nil, delay: nil)
+      click(x, y, button: button, clickCount: 2, delay: delay)
+    end
   end
 end

data/lib/playwright/playwright_api.rb

@@ -124,7 +124,9 @@ module Playwright
     end
 
     private def unwrap_impl(object)
-      if object.is_a?(PlaywrightApi)
+      if object.is_a?(Array)
+        object.map { |obj| unwrap_impl(obj) }
+      elsif object.is_a?(PlaywrightApi)
         object.instance_variable_get(:@impl)
       else
         object

data/lib/playwright/route_handler_entry.rb

@@ -0,0 +1,28 @@
+module Playwright
+  class RouteHandlerEntry
+    # @param url [String]
+    # @param handler [Proc]
+    def initialize(url, handler)
+      @url_value = url
+      @url_matcher = UrlMatcher.new(url)
+      @handler = handler
+    end
+
+    def handle(route, request)
+      if @url_matcher.match?(request.url)
+        @handler.call(route, request)
+        true
+      else
+        false
+      end
+    end
+
+    def same_value?(url:, handler: nil)
+      if handler
+        @url_value == url && @handler == handler
+      else
+        @url_value == url
+      end
+    end
+  end
+end

data/lib/playwright/select_option_values.rb

@@ -1,18 +1,30 @@
 module Playwright
   class SelectOptionValues
     def initialize(element: nil, index: nil, value: nil, label: nil)
-      @params =
-        if element
-          convert(elmeent)
-        elsif index
-          convert(index)
-        elsif value
-          convert(value)
-        elsif label
-          convert(label)
-        else
-          {}
-        end
+      params = {}
+
+      options = []
+      if value
+        options.concat(convert(:value, value))
+      end
+
+      if index
+        options.concat(convert(:index, index))
+      end
+
+      if label
+        options.concat(convert(:label, label))
+      end
+
+      unless options.empty?
+        params[:options] = options
+      end
+
+      if element
+        params[:elements] = convert(:element, element)
+      end
+
+      @params = params
     end
 
     # @return [Hash]
@@ -20,22 +32,19 @@ module Playwright
       @params
     end
 
-    private def convert(values)
-      return convert([values]) unless values.is_a?(Enumerable)
-      return {} if values.empty?
+    private def convert(key, values)
+      return convert(key, [values]) unless values.is_a?(Enumerable)
+      return [] if values.empty?
       values.each_with_index do |value, index|
-        unless values
+        unless value
           raise ArgumentError.new("options[#{index}]: expected object, got null")
         end
       end
 
-      case values.first
-      when ElementHandle
-        { elements: values.map(&:channel) }
-      when String
-        { options: values.map { |value| { value: value } } }
+      if key == :element
+        values.map(&:channel)
       else
-        { options: values }
+        values.map { |value| { key => value } }
       end
     end
   end

data/lib/playwright/transport.rb

@@ -12,39 +12,46 @@ module Playwright
     def initialize(playwright_cli_executable_path:)
       @driver_executable_path = playwright_cli_executable_path
       @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+      @mutex = Mutex.new
     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)
-      @stdin.write([msg.size].pack('V')) # unsigned 32bit, little endian
-      @stdin.write(msg)
-    rescue Errno::EPIPE
+      @mutex.synchronize {
+        @stdin.write([msg.bytes.length].pack('V')) # unsigned 32bit, little endian, real byte size instead of chars
+        @stdin.write(msg) # write UTF-8 in binary mode as byte stream
+      }
+    rescue Errno::EPIPE, IOError
       raise AlreadyDisconnectedError.new('send_message failed')
     end
 
     # Terminate playwright-cli driver.
     def stop
       [@stdin, @stdout, @stderr].each { |io| io.close unless io.closed? }
+      @thread&.terminate
     end
 
     # Start `playwright-cli run-driver`
     #
     # @note This method blocks until playwright-cli exited. Consider using Thread or Future.
-    def run
-      @stdin, @stdout, @stderr, @thread = Open3.popen3(@driver_executable_path, 'run-driver')
+    def async_run
+      @stdin, @stdout, @stderr, @thread = Open3.popen3("#{@driver_executable_path} run-driver")
+      @stdin.binmode  # Ensure Strings are written 1:1 without encoding conversion, necessary for integer values
 
       Thread.new { handle_stdout }
       Thread.new { handle_stderr }
-
-      @thread.join
     end
 
     private
@@ -69,6 +76,21 @@ module Playwright
 
     def handle_stderr
       while err = @stderr.read
+        # sometimed driver crashes with the error below.
+        # --------
+        # undefined:1
+        # �
+        # ^
+
+        # SyntaxError: Unexpected token � in JSON at position 0
+        #     at JSON.parse (<anonymous>)
+        #     at Transport.transport.onmessage (/home/runner/work/playwright-ruby-client/playwright-ruby-client/node_modules/playwright/lib/cli/driver.js:42:73)
+        #     at Immediate.<anonymous> (/home/runner/work/playwright-ruby-client/playwright-ruby-client/node_modules/playwright/lib/protocol/transport.js:74:26)
+        #     at processImmediate (internal/timers.js:461:21)
+        if err.include?('undefined:1')
+          @on_driver_crashed&.call
+          break
+        end
         $stderr.write(err)
       end
     rescue IOError