playwright-ruby-client 0.0.6 → 0.0.7

data/lib/playwright/channel_owners/js_handle.rb

@@ -1,4 +1,55 @@
 module Playwright
   define_channel_owner :JSHandle do
+    def after_initialize
+      @preview = @initializer['preview']
+      @channel.on('previewUpdated', method(:on_preview_updated))
+    end
+
+    def to_s
+      @preview
+    end
+
+    private def on_preview_updated(preview)
+      @preview = preview
+    end
+
+    def evaluate(pageFunction, arg: nil)
+      if JavaScript.function?(pageFunction)
+        JavaScript::Function.new(pageFunction, arg).evaluate(@channel)
+      else
+        JavaScript::Expression.new(pageFunction).evaluate(@channel)
+      end
+    end
+
+    def evaluate_handle(pageFunction, arg: nil)
+      if JavaScript.function?(pageFunction)
+        JavaScript::Function.new(pageFunction, arg).evaluate_handle(@channel)
+      else
+        JavaScript::Expression.new(pageFunction).evaluate_handle(@channel)
+      end
+    end
+
+    def get_properties
+      resp = @channel.send_message_to_server('getPropertyList')
+      resp.map { |prop| [prop['name'], ChannelOwner.from(prop['value'])] }.to_h
+    end
+
+    def get_property(name)
+      resp = @channel.send_message_to_server('getProperty', name: name)
+      ChannelOwner.from(resp)
+    end
+
+    def as_element
+      nil
+    end
+
+    def dispose
+      @channel.send_message_to_server('dispose')
+    end
+
+    def json_value
+      value = @channel.send_message_to_server('jsonValue')
+      JavaScript::ValueParser.new(value).parse
+    end
   end
 end

data/lib/playwright/channel_owners/page.rb

@@ -143,6 +143,19 @@ module Playwright
       @main_frame.goto(url, timeout: timeout,  waitUntil: waitUntil, referer: referer)
     end
 
+    def reload(timeout: nil, waitUntil: nil)
+      params = {
+        timeout: timeout,
+        waitUntil: waitUntil,
+      }.compact
+      resp = @channel.send_message_to_server('reoad', params)
+      ChannelOwners::Response.from_nullable(resp)
+    end
+
+    def wait_for_load_state(state: nil, timeout: nil)
+      @main_frame.wait_for_load_state(state: state, timeout: timeout)
+    end
+
     def set_viewport_size(viewportSize)
       @viewport_size = viewportSize
       @channel.send_message_to_server('setViewportSize', { viewportSize: viewportSize })
@@ -167,7 +180,7 @@ module Playwright
         timeout: timeout,
       }.compact
       encoded_binary = @channel.send_message_to_server('screenshot', params)
-      decoded_binary = Base64.decode64(encoded_binary)
+      decoded_binary = Base64.strict_decode64(encoded_binary)
       if path
         File.open(path, 'wb') do |f|
           f.write(decoded_binary)
@@ -217,18 +230,43 @@ module Playwright
       )
     end
 
+    def dblclick(
+          selector,
+          button: nil,
+          delay: nil,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil)
+      @main_frame.dblclick(
+        selector,
+        button: button,
+        delay: delay,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+      )
+    end
+
+    def fill(selector, value, noWaitAfter: nil, timeout: nil)
+      @main_frame.fill(selector, value, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
     def focus(selector, timeout: nil)
       @main_frame.focus(selector, timeout: timeout)
     end
 
-    def type_text(
+    def type(
       selector,
       text,
       delay: nil,
       noWaitAfter: nil,
       timeout: nil)
 
-      @main_frame.type_text(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+      @main_frame.type(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
     end
 
     def press(
@@ -259,7 +297,7 @@ module Playwright
       end
     end
 
-    def wait_for_event(event, optionsOrPredicate: nil, &block)
+    def expect_event(event, optionsOrPredicate: nil, &block)
       predicate, timeout =
         case optionsOrPredicate
         when Proc
@@ -289,15 +327,15 @@ module Playwright
       wait_helper.promise.value!
     end
 
-    def wait_for_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
-      @main_frame.wait_for_navigation(
+    def expect_navigation(timeout: nil, url: nil, waitUntil: nil, &block)
+      @main_frame.expect_navigation(
         timeout: timeout,
         url: url,
         waitUntil: waitUntil,
         &block)
     end
 
-    def wait_for_request(urlOrPredicate, timeout: nil)
+    def expect_request(urlOrPredicate, timeout: nil)
       predicate =
         case urlOrPredicate
         when String, Regexp
@@ -309,10 +347,10 @@ module Playwright
           -> (_) { true }
         end
 
-      wait_for_event(Events::Page::Request, optionsOrPredicate: { predicate: predicate, timeout: timeout})
+      expect_event(Events::Page::Request, optionsOrPredicate: { predicate: predicate, timeout: timeout})
     end
 
-    def wait_for_response(urlOrPredicate, timeout: nil)
+    def expect_response(urlOrPredicate, timeout: nil)
       predicate =
         case urlOrPredicate
         when String, Regexp
@@ -324,7 +362,7 @@ module Playwright
           -> (_) { true }
         end
 
-      wait_for_event(Events::Page::Response, optionsOrPredicate: { predicate: predicate, timeout: timeout})
+      expect_event(Events::Page::Response, optionsOrPredicate: { predicate: predicate, timeout: timeout})
     end
 
     # called from BrowserContext#on_page with send(:update_browser_context, page), so keep private.

data/lib/playwright/channel_owners/webkit_browser.rb

@@ -2,7 +2,7 @@ require_relative './browser'
 
 module Playwright
   module ChannelOwners
-    class WebkitBrowser < Browser
+    class WebKitBrowser < Browser
     end
   end
 end

data/lib/playwright/connection.rb

@@ -55,10 +55,13 @@ module Playwright
           method: method,
           params: replace_channels_with_guids(params),
         }
-        @transport.send_message(message)
-      rescue Transport::AlreadyDisconnectedError => err
-        @callbacks.delete(id)
-        callback.reject(err)
+        begin
+          @transport.send_message(message)
+        rescue => err
+          @callbacks.delete(id)
+          callback.reject(err)
+          raise unless err.is_a?(Transport::AlreadyDisconnectedError)
+        end
       end
 
       callback
@@ -132,7 +135,7 @@ module Playwright
         unless object
           raise "Cannot find object to dispose: #{guid}"
         end
-        object.dispose
+        object.send(:dispose!)
         return
       end
 
@@ -153,7 +156,7 @@ module Playwright
       end
 
       if payload.is_a?(Channel)
-        { guid: payload.guid }
+        return { guid: payload.guid }
       end
 
       if payload.is_a?(Hash)

data/lib/playwright/errors.rb

@@ -3,7 +3,7 @@ module Playwright
     # ref: https://github.com/microsoft/playwright-python/blob/0b4a980fed366c4c1dee9bfcdd72662d629fdc8d/playwright/_impl/_helper.py#L155
     def self.parse(error_payload)
       if error_payload['name'] == 'TimeoutError'
-        Playwright::TimeoutError.new(
+        TimeoutError.new(
           message: error_payload['message'],
           stack: error_payload['stack'].split("\n"),
         )

data/lib/playwright/input_files.rb

@@ -0,0 +1,42 @@
+require 'base64'
+require 'mime/types'
+
+module Playwright
+  class InputFiles
+    def initialize(files)
+      @params = convert(files)
+    end
+
+    def as_params
+      @params
+    end
+
+    private def convert(files)
+      return convert([files]) unless files.is_a?(Array)
+
+      files.map do |file|
+        case file
+        when String
+          {
+            name: File.basename(file),
+            mimeType: mime_type_for(file),
+            buffer: Base64.strict_encode64(File.read(file)),
+          }
+        when File
+          {
+            name: File.basename(file.path),
+            mimeType: mime_type_for(file.path),
+            buffer: Base64.strict_encode64(file.read),
+          }
+        else
+          raise ArgumentError.new('file must be a String or File.')
+        end
+      end
+    end
+
+    private def mime_type_for(filepath)
+      mime_types = MIME::Types.type_for(filepath)
+      mime_types.first || 'application/octet-stream'
+    end
+  end
+end

data/lib/playwright/input_types/keyboard.rb

@@ -13,7 +13,7 @@ module Playwright
       @channel.send_message_to_server('keyboardInsertText', text: text)
     end
 
-    def type_text(text, delay: nil)
+    def type(text, delay: nil)
       params = {
         text: text,
         delay: delay,

data/lib/playwright/javascript/value_serializer.rb

@@ -15,9 +15,9 @@ module Playwright
       # ref: https://github.com/microsoft/playwright-python/blob/25a99d53e00e35365cf5113b9525272628c0e65f/playwright/_impl/_js_handle.py#L99
       private def serialize_value(value)
         case value
-        when JSHandle
+        when ChannelOwners::JSHandle
           index = @handles.count
-          @handles << v
+          @handles << value.channel
           { h: index }
         when nil
           { v: 'undefined' }
@@ -28,23 +28,23 @@ module Playwright
         when -Float::INFINITY
           { v: '-Infinity' }
         when true, false
-          { b: v }
+          { b: value }
         when Numeric
-          { n: v }
+          { n: value }
         when String
-          { s: v }
+          { s: value }
         when Time
           require 'time'
-          { d: v.utc.iso8601 }
+          { d: value.utc.iso8601 }
         when Regexp
           flags = []
-          flags << 'ms' if (v.options & Regexp::MULTILINE) != 0
-          flags << 'i' if (v.options & Regexp::IGNORECASE) != 0
-          { r: { p: v.source, f: flags.join('') } }
+          flags << 'ms' if (value.options & Regexp::MULTILINE) != 0
+          flags << 'i' if (value.options & Regexp::IGNORECASE) != 0
+          { r: { p: value.source, f: flags.join('') } }
         when Array
-          { a: v.map { |value| serialize_value(value) } }
+          { a: value.map { |v| serialize_value(v) } }
         when Hash
-          { o: v.map { |key, value| [key, serialize_value(value)] }.to_h }
+          { o: value.map { |key, v| [key, serialize_value(v)] }.to_h }
         else
           raise ArgumentError.new("Unexpected value: #{value}")
         end

data/lib/playwright/playwright_api.rb

@@ -83,5 +83,13 @@ module Playwright
         object
       end
     end
+
+    private def unwrap_impl(object)
+      if object.is_a?(PlaywrightApi)
+        object.instance_variable_get(:@impl)
+      else
+        object
+      end
+    end
   end
 end

data/lib/playwright/select_option_values.rb

@@ -0,0 +1,32 @@
+module Playwright
+  class SelectOptionValues
+    def initialize(values)
+      @params = convert(values)
+    end
+
+    # @return [Hash]
+    def as_params
+      @params
+    end
+
+    private def convert(values)
+      return {} unless values
+      return convert([values]) unless values.is_a?('Array')
+      return {} if values.empty?
+      values.each_with_index do |value, index|
+        unless values
+          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 } } }
+      else
+        { options: values }
+      end
+    end
+  end
+end

data/lib/playwright/utils.rb

@@ -1,5 +1,23 @@
 module Playwright
   module Utils
+    module PrepareBrowserContextOptions
+      # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
+      private def prepare_browser_context_options(params)
+        if params[:viewport] == 0
+          params.delete(:viewport)
+          params[:noDefaultViewport] = true
+        end
+        if params[:extraHTTPHeaders]
+          # TODO
+        end
+        if params[:storageState].is_a?(String)
+          params[:storageState] = JSON.parse(File.read(params[:storageState]))
+        end
+
+        params
+      end
+    end
+
     module Errors
       module SafeCloseError
         # @param err [Exception]

data/lib/playwright/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

data/lib/playwright_api/android.rb

@@ -0,0 +1,33 @@
+module Playwright
+  # @nodoc
+  class Android < PlaywrightApi
+
+    # @nodoc
+    def after_initialize
+      wrap_impl(@impl.after_initialize)
+    end
+
+    # @nodoc
+    def devices
+      wrap_impl(@impl.devices)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    end
+  end
+end