playwright-ruby-client 0.0.3

data/lib/playwright/channel_owners/browser_type.rb

@@ -0,0 +1,26 @@
+module Playwright
+  define_channel_owner :BrowserType do
+    def name
+      @initializer['name']
+    end
+
+    def executable_path
+      @initializer['executablePath']
+    end
+
+    def launch(options, &block)
+      resp = @channel.send_message_to_server('launch', options.compact)
+      browser = ChannelOwners::Browser.from(resp)
+
+      if block
+        begin
+          block.call(browser)
+        ensure
+          browser.close
+        end
+      else
+        browser
+      end
+    end
+  end
+end

data/lib/playwright/channel_owners/chromium_browser.rb

@@ -0,0 +1,8 @@
+require_relative './browser'
+
+module Playwright
+  module ChannelOwners
+    class ChromiumBrowser < Browser
+    end
+  end
+end

data/lib/playwright/channel_owners/chromium_browser_context.rb

@@ -0,0 +1,8 @@
+require_relative './browser_context'
+
+module Playwright
+  module ChannelOwners
+    class ChromiumBrowserContext < BrowserContext
+    end
+  end
+end

data/lib/playwright/channel_owners/electron.rb

@@ -0,0 +1,3 @@
+module Playwright
+  define_channel_owner :Electron
+end

data/lib/playwright/channel_owners/firefox_browser.rb

@@ -0,0 +1,8 @@
+require_relative './browser'
+
+module Playwright
+  module ChannelOwners
+    class FirefoxBrowser < Browser
+    end
+  end
+end

data/lib/playwright/channel_owners/frame.rb

@@ -0,0 +1,44 @@
+module Playwright
+  # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_frame.py
+  define_channel_owner :Frame do
+    def after_initialize
+      @event_emitter = Object.new.extend(EventEmitter)
+      if @initializer['parentFrame']
+        @parent_frame = self.from(@initializer['parentFrame'])
+        @parent_frame.send(:append_child_frame_from_child, self)
+      end
+      @name = @initializer['name']
+      @url = @initializer['url']
+      @detached = false
+      @child_frames = Set.new
+      @load_states = Set.new(@initializer['loadStates'])
+    end
+
+    attr_reader :page
+
+    def goto(url, timeout: nil, waitUntil: nil, referer: nil)
+      params = {
+        url: url,
+        timeout: timeout,
+        waitUntil: waitUntil,
+        referer: referer
+      }.compact
+      resp = @channel.send_message_to_server('goto', params)
+      ChannelOwners::Response.from(resp)
+    end
+
+    private
+
+    # @param page [Page]
+    # @note This method should be used internally. Accessed via .send method, so keep private!
+    def update_page_from_page(page)
+      @page = page
+    end
+
+    # @param child [Frame]
+    # @note This method should be used internally. Accessed via .send method, so keep private!
+    def append_child_frame_from_child(frame)
+      @child_frames << frame
+    end
+  end
+end

data/lib/playwright/channel_owners/page.rb

@@ -0,0 +1,53 @@
+require 'base64'
+
+module Playwright
+  # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_page.py
+  define_channel_owner :Page do
+    attr_writer :owned_context
+
+    def after_initialize
+      @accessibility = Accessibility.new(@channel)
+      @keyboard = Keyboard.new(@channel)
+      @mouse = Mouse.new(@channel)
+      @touchscreen = Touchscreen.new(@channel)
+
+      @main_frame = ChannelOwners::Frame.from(@initializer['mainFrame'])
+      @main_frame.send(:update_page_from_page, self)
+      @frames = Set.new
+      @frames << @main_frame
+    end
+
+    attr_reader :accessibility, :keyboard, :mouse, :touchscreen, :main_frame
+
+    def goto(url, timeout: nil, waitUntil: nil, referer: nil)
+      @main_frame.goto(url, timeout: timeout,  waitUntil: waitUntil, referer: referer)
+    end
+
+    def screenshot(
+      path: nil,
+      type: nil,
+      quality: nil,
+      fullPage: nil,
+      clip: nil,
+      omitBackground: nil,
+      timeout: nil)
+
+      params = {
+        type: type,
+        quality: quality,
+        fullPage: fullPage,
+        clip: clip,
+        omitBackground: omitBackground,
+        timeout: timeout,
+      }.compact
+      encoded_binary = @channel.send_message_to_server('screenshot', params)
+      decoded_binary = Base64.decode64(encoded_binary)
+      if path
+        File.open(path, 'wb') do |f|
+          f.write(decoded_binary)
+        end
+      end
+      decoded_binary
+    end
+  end
+end

data/lib/playwright/channel_owners/playwright.rb

@@ -0,0 +1,57 @@
+module Playwright
+  define_channel_owner :Playwright do
+    def chromium
+      @chromium ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['chromium'])
+    end
+
+    def firefox
+      @firefox ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['firefox'])
+    end
+
+    def webkit
+      @webkit ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['webkit'])
+    end
+
+    def android
+      @android ||= ::Playwright::ChannelOwners::Android.from(@initializer['android'])
+    end
+
+    def electron
+      @electron ||= ::Playwright::ChannelOwners::Electron.from(@initializer['electron'])
+    end
+
+    class DeviceDescriptor
+      class Viewport
+        def initialize(hash)
+          @width = hash['width']
+          @heirhgt = hash['height']
+        end
+        attr_reader :width, :height
+      end
+
+      def initialize(hash)
+        @user_agent = hash["userAgent"]
+        @viewport = Viewport.new(hash["viewport"])
+        @device_scale_factor = hash["deviceScaleFactor"]
+        @is_mobile = hash["isMobile"]
+        @has_touch = hash["hasTouch"]
+      end
+
+      attr_reader :user_agent, :viewport, :device_scale_factor
+
+      def mobile?
+        @is_mobile
+      end
+
+      def has_touch?
+        @has_touch
+      end
+    end
+
+    def devices
+      @devices ||= @initializer['deviceDescriptors'].map do |item|
+        [item['name'], DeviceDescriptor.new(item['descriptor'])]
+      end.to_h
+    end
+  end
+end

data/lib/playwright/channel_owners/request.rb

@@ -0,0 +1,5 @@
+module Playwright
+  # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
+  define_channel_owner :Request do
+  end
+end

data/lib/playwright/channel_owners/response.rb

@@ -0,0 +1,5 @@
+module Playwright
+  # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
+  define_channel_owner :Response do
+  end
+end

data/lib/playwright/channel_owners/selectors.rb

@@ -0,0 +1,4 @@
+module Playwright
+  # https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_selectors.py
+  define_channel_owner :Selectors
+end

data/lib/playwright/channel_owners/webkit_browser.rb

@@ -0,0 +1,8 @@
+require_relative './browser'
+
+module Playwright
+  module ChannelOwners
+    class WebkitBrowser < Browser
+    end
+  end
+end

data/lib/playwright/connection.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Playwright
+  # https://github.com/microsoft/playwright/blob/master/src/client/connection.ts
+  # https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_connection.py
+  # https://github.com/microsoft/playwright-java/blob/master/playwright/src/main/java/com/microsoft/playwright/impl/Connection.java
+  class Connection
+    def initialize(playwright_cli_executable_path:)
+      @transport = Transport.new(
+        playwright_cli_executable_path: playwright_cli_executable_path
+      )
+      @transport.on_message_received do |message|
+        dispatch(message)
+      end
+
+      @objects = {} # Hash[ guid => ChannelOwner ]
+      @waiting_for_object = {} # Hash[ guid => Promise<ChannelOwner> ]
+      @callbacks = {} # Hash [ guid => Promise<ChannelOwner> ]
+      @root_object = RootChannelOwner.new(self)
+    end
+
+    def run
+      @transport.run
+    end
+
+    def stop
+      @transport.stop
+    end
+
+    def async_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!
+    end
+
+    def async_send_message_to_server(guid, method, params)
+      callback = Concurrent::Promises.resolvable_future
+
+      with_generated_id do |id|
+        # register callback promise object first.
+        # @see https://github.com/YusukeIwaki/puppeteer-ruby/pull/34
+        @callbacks[id] = callback
+
+        message = {
+          id: id,
+          guid: guid,
+          method: method,
+          params: replace_channels_with_guids(params),
+        }
+        @transport.send_message(message)
+      rescue Transport::AlreadyDisconnectedError => err
+        @callbacks.delete(id)
+        callback.reject(err)
+      end
+
+      callback
+    end
+
+    def send_message_to_server(guid, method, params)
+      async_send_message_to_server(guid, method, params).value!
+    end
+
+    private
+
+    # ```usage
+    # connection.with_generated_id do |id|
+    #   # play with id
+    # end
+    # ````
+    def with_generated_id(&block)
+      @last_id ||= 0
+      block.call(@last_id += 1)
+    end
+
+    # @param guid [String]
+    # @param parent [Playwright::ChannelOwner]
+    # @note This method should be used internally. Accessed via .send method from Playwright::ChannelOwner, so keep private!
+    def update_object_from_channel_owner(guid, parent)
+      @objects[guid] = parent
+    end
+
+    # @param guid [String]
+    # @note This method should be used internally. Accessed via .send method from Playwright::ChannelOwner, so keep private!
+    def delete_object_from_channel_owner(guid)
+      @objects.delete(guid)
+    end
+
+    def dispatch(msg)
+      id = msg['id']
+      if id
+        callback = @callbacks.delete(id)
+
+        unless callback
+          raise "Cannot find command to respond: #{id}"
+        end
+
+        error = msg['error']
+        if error
+          callback.reject(::Playwright::Error.parse(error['error']))
+        else
+          result = replace_guids_with_channels(msg['result'])
+          callback.fulfill(result)
+        end
+
+        return
+      end
+
+      guid = msg['guid']
+      method = msg['method']
+      params = msg['params']
+
+      if method == "__create__"
+        create_remote_object(
+          parent_guid: guid,
+          type: params["type"],
+          guid: params["guid"],
+          initializer: params["initializer"],
+        )
+        return
+      end
+
+      if method == "__dispose__"
+        object = @objects[guid]
+        unless object
+          raise "Cannot find object to dispose: #{guid}"
+        end
+        object.dispose
+        return
+      end
+
+      object = @objects[guid]
+      unless object
+        raise "Cannot find object to emit \"#{method}\": #{guid}"
+      end
+      object.channel.emit(method, replace_guids_with_channels(params))
+    end
+
+    def replace_channels_with_guids(payload)
+      if payload.nil?
+        return nil
+      end
+
+      if payload.is_a?(Array)
+        return payload.map{ |pl| replace_channels_with_guids(pl) }
+      end
+
+      if payload.is_a?(Channel)
+        { guid: payload.guid }
+      end
+
+      if payload.is_a?(Hash)
+        return payload.map { |k, v| [k, replace_channels_with_guids(v)] }.to_h
+      end
+
+      payload
+    end
+
+    def replace_guids_with_channels(payload)
+      if payload.nil?
+        return nil
+      end
+
+      if payload.is_a?(Array)
+        return payload.map{ |pl| replace_guids_with_channels(pl) }
+      end
+
+      if payload.is_a?(Hash)
+        guid = payload['guid']
+        if guid && @objects[guid]
+          return @objects[guid].channel
+        end
+
+        return payload.map { |k, v| [k, replace_guids_with_channels(v)] }.to_h
+      end
+
+      payload
+    end
+
+    # @return [Playwright::ChannelOwner|nil]
+    def create_remote_object(parent_guid:, type:, guid:, initializer:)
+      parent = @objects[parent_guid]
+      unless parent
+        raise "Cannot find parent object #{parent_guid} to create #{guid}"
+      end
+      initializer = replace_guids_with_channels(initializer)
+
+      params = [
+        parent,
+        type,
+        guid,
+        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
+          params << browser_name
+          'BrowserContext'
+        end
+      else
+        type
+      end
+
+      result =
+        begin
+          ChannelOwners.const_get(class_name).new(*params)
+        rescue NameError
+          raise "Missing type #{type}"
+        end
+
+      callback = @waiting_for_object.delete(guid)
+      callback&.fulfill(result)
+
+      result
+    end
+  end
+end