playwright-ruby-client 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b77f5e67e8a75aec27eca18c85bcaaf3236fcc0822659de3462a7f4d41d3a1a8
-  data.tar.gz: 7791bc627ddcd7fc39fa36b7ec6f393c855d0cb506b5834922b43f84839dac63
+  metadata.gz: c54a8690be4b1b2e33cecb6cda92071cd1d6867647fe939b004bf0434c31c74e
+  data.tar.gz: 1c2c784a5970c7a89bffc6bdb12cf7c8e1353a676881a99862bb9bbe30dd3dea
 SHA512:
-  metadata.gz: 3ffbf8ebba62b54b51534b5f33f45dd02df9f73824b267500b9265827bb09b01898849fb43c461a2798c276801ae69a6beb52018872c4d7740ba56ff8ab99686
-  data.tar.gz: 8b7acc19dd31389c0ea3361a8be430177d2319ec20284ffac65117a9421810b26808c1ab61bc33298e8bfd89c617772750f7c61b21258aebebd6db7d93598923
+  metadata.gz: e9ca66a5edc3d168e16b552f3c84e4b4a939a7e8610da439fdea8350a87fed0656a9b5c715e4ac384d23b1d089ab23fa61ccd06288b1f11045aa83a3351a4f94
+  data.tar.gz: cad563aa4e2f81a026f08a04a7fd3caf1295f6419b01f1601d324583243dd839bb4b7f3aec73967555c4dbb6b8ffb8b65e7607836ec2c11231512c6e45fbf526

data/README.md

@@ -8,14 +8,14 @@ Note: Currently, this Gem is just a PoC (Proof of Concept). If you want to devel
 
 ## Getting Started
 
-At this point, playwright-ruby-client doesn't include the downloader of playwright-cli, so **we have to install [playwright-cli](https://github.com/microsoft/playwright-cli) in advance**.
+At this point, playwright-ruby-client doesn't include the downloader of playwright driver, so **we have to install [playwright CLI](https://github.com/microsoft/playwright-cli) in advance**.
 
 ```sh
-npm install playwright-cli
-./node_modules/.bin/playwright-cli install
+npm install playwright
+./node_modules/.bin/playwright install
 ```
 
-and then, set `playwright_cli_executable_path: ./node_modules/.bin/playwright-cli` at `Playwright.create`.
+and then, set `playwright_cli_executable_path: ./node_modules/.bin/playwright` at `Playwright.create`.
 
 Instead of npm install, you can also directly download playwright driver from playwright.azureedge.net/builds/. The URL can be easily detected from [here](https://github.com/microsoft/playwright-python/blob/79f6ce0a6a69c480573372706df84af5ef99c4a4/setup.py#L56-L61)
 
@@ -24,7 +24,7 @@ Instead of npm install, you can also directly download playwright driver from pl
 ```ruby
 require 'playwright'
 
-Playwright.create(playwright_cli_executable_path: '/path/to/playwright-cli') do |playwright|
+Playwright.create(playwright_cli_executable_path: '/path/to/playwright') do |playwright|
   playwright.chromium.launch(headless: false) do |browser|
     page = browser.new_page
     page.goto('https://github.com/YusukeIwaki')
@@ -33,6 +33,8 @@ Playwright.create(playwright_cli_executable_path: '/path/to/playwright-cli') do
 end
 ```
 
+![image](https://user-images.githubusercontent.com/11763113/104339718-412f9180-553b-11eb-9116-908e1e4b5186.gif)
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/playwright.rb

@@ -10,12 +10,16 @@ require 'concurrent'
 require 'playwright/errors'
 require 'playwright/events'
 require 'playwright/event_emitter'
+require 'playwright/javascript'
+require 'playwright/utils'
 
 require 'playwright/channel'
 require 'playwright/channel_owner'
 require 'playwright/connection'
+require 'playwright/timeout_settings'
 require 'playwright/transport'
 require 'playwright/version'
+require 'playwright/wait_helper'
 
 require 'playwright/playwright_api'
 # load generated files

data/lib/playwright/channel_owner.rb

@@ -6,6 +6,10 @@ module Playwright
       channel.object
     end
 
+    def self.from_nullable(channel)
+      channel&.object
+    end
+
     # @param parent [Playwright::ChannelOwner|Playwright::Connection]
     # @param type [String]
     # @param guid [String]
@@ -45,6 +49,15 @@ module Playwright
       @objects.clear
     end
 
+    # Suppress long long inspect log and avoid RSpec from hanging up...
+    def inspect
+      to_s
+    end
+
+    def to_s
+      "#<#{@guid}>"
+    end
+
     private
 
     def after_initialize

data/lib/playwright/channel_owners/browser.rb

@@ -1,9 +1,11 @@
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser.py
   define_channel_owner :Browser do
+    include Utils::Errors::SafeCloseError
+
     def after_initialize
       @contexts = Set.new
-      @channel.on('close', method(:handle_close))
+      @channel.on('close', method(:on_close))
     end
 
     def contexts
@@ -57,24 +59,15 @@ module Playwright
       @initializer['version']
     end
 
-    private
-
-    def handle_close(_ = {})
+    private def on_close(_ = {})
       @connected = false
       emit(Events::Browser::Disconnected)
       @closed_or_closing = false
     end
 
-    # @param err [Exception]
-    def safe_close_error?(err)
-      return true if err.is_a?(Transport::AlreadyDisconnectedError)
-
-      [
-        'Browser has been closed',
-        'Target page, context or browser has been closed',
-      ].any? do |closed_message|
-        err.message.end_with?(closed_message)
-      end
+    # called from BrowserContext#on_close with send(:remove_context), so keep private.
+    private def remove_context(context)
+      @contexts.delete(context)
     end
   end
 end

data/lib/playwright/channel_owners/browser_context.rb

@@ -1,13 +1,56 @@
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser_context.py
   define_channel_owner :BrowserContext do
+    include Utils::Errors::SafeCloseError
     attr_writer :browser, :owner_page, :options
 
+    def after_initialize
+      @pages = Set.new
+
+      @channel.once('close', ->(_) { on_close })
+      @channel.on('page', ->(hash) { on_page(ChannelOwners::Page.from(hash['page']) )})
+    end
+
+    private def on_page(page)
+      page.send(:update_browser_context, self)
+      @pages << page
+      emit(Events::BrowserContext::Page, page)
+    end
+
+    def pages
+      @pages.to_a
+    end
+
     # @returns [Playwright::Page]
     def new_page
       raise 'Please use browser.new_context' if @owner_page
       resp = @channel.send_message_to_server('newPage')
       ChannelOwners::Page.from(resp)
     end
+
+    private def on_close
+      @closed_or_closing = true
+      @browser&.send(:remove_context, self)
+      emit(Events::BrowserContext::Close)
+    end
+
+    def close
+      return if @closed_or_closing
+      @closed_or_closing = true
+      @channel.send_message_to_server('close')
+      nil
+    rescue => err
+      raise unless safe_close_error?(err)
+    end
+
+    # called from Page#on_close with send(:remove_page, page), so keep private
+    private def remove_page(page)
+      @pages.delete(page)
+    end
+
+    # called from Page with send(:_timeout_settings), so keep private.
+    private def _timeout_settings
+      @timeout_settings
+    end
   end
 end

data/lib/playwright/channel_owners/console_message.rb

@@ -1,9 +1,5 @@
 module Playwright
   define_channel_owner :ConsoleMessage do
-    def to_s
-      @initializer['text']
-    end
-
     def type
       @initializer['type']
     end

data/lib/playwright/channel_owners/frame.rb

@@ -2,9 +2,8 @@ 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 = ChannelOwners::Frame.from(@initializer['parentFrame'])
         @parent_frame.send(:append_child_frame_from_child, self)
       end
       @name = @initializer['name']
@@ -12,9 +11,36 @@ module Playwright
       @detached = false
       @child_frames = Set.new
       @load_states = Set.new(@initializer['loadStates'])
+      @event_emitter = Object.new.extend(EventEmitter)
+
+      @channel.on('loadstate', ->(params) {
+        on_load_state(add: params['add'], remove: params['remove'])
+      })
+      @channel.on('navigated', method(:on_frame_navigated))
     end
 
-    attr_reader :page
+    attr_reader :page, :parent_frame
+    attr_writer :detached
+
+    private def on_load_state(add:, remove:)
+      if add
+        @load_states << add
+        @event_emitter.emit('loadstate', add)
+      end
+      if remove
+        @load_states.delete(remove)
+      end
+    end
+
+    private def on_frame_navigated(event)
+      @url = event['url']
+      @name = event['name']
+      @event_emitter.emit('navigated', event)
+
+      unless event['error']
+        @page&.emit('framenavigated', self)
+      end
+    end
 
     def goto(url, timeout: nil, waitUntil: nil, referer: nil)
       params = {
@@ -24,20 +50,108 @@ module Playwright
         referer: referer
       }.compact
       resp = @channel.send_message_to_server('goto', params)
-      ChannelOwners::Response.from(resp)
+      ChannelOwners::Response.from_nullable(resp)
+    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 content
+      @channel.send_message_to_server('content')
+    end
+
+    def set_content(html, timeout: nil, waitUntil: nil)
+      params = {
+        html: html,
+        timeout: timeout,
+        waitUntil: waitUntil,
+      }.compact
+
+      @channel.send_message_to_server('setContent', params)
+
+      nil
+    end
+
+    def focus(selector, timeout: nil)
+      params = { selector: selector, timeout: timeout }.compact
+      @channel.send_message_to_server('focus', params)
+      nil
     end
 
-    private
+    def type_text(
+      selector,
+      text,
+      delay: nil,
+      noWaitAfter: nil,
+      timeout: nil)
+
+      params = {
+        selector: selector,
+        text: text,
+        delay: delay,
+        noWaitAfter: noWaitAfter,
+        timeout: timeout,
+      }.compact
+
+      @channel.send_message_to_server('type', params)
+    end
+
+    def press(
+      selector,
+      key,
+      delay: nil,
+      noWaitAfter: nil,
+      timeout: nil)
+
+      params = {
+        selector: selector,
+        key: key,
+        delay: delay,
+        noWaitAfter: noWaitAfter,
+        timeout: timeout,
+      }.compact
+
+      @channel.send_message_to_server('press', params)
+    end
+
+    def name
+      @name || ''
+    end
+
+    def url
+      @url || ''
+    end
+
+    def child_frames
+      @child_frames.to_a
+    end
+
+    def title
+      @channel.send_message_to_server('title')
+    end
 
     # @param page [Page]
     # @note This method should be used internally. Accessed via .send method, so keep private!
-    def update_page_from_page(page)
+    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)
+    private def append_child_frame_from_child(frame)
       @child_frames << frame
     end
   end

data/lib/playwright/channel_owners/page.rb

@@ -3,19 +3,40 @@ require 'base64'
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_page.py
   define_channel_owner :Page do
+    include Utils::Errors::SafeCloseError
     attr_writer :owned_context
 
     def after_initialize
+      @browser_context = @parent
+      @timeout_settings = TimeoutSettings.new(@browser_context.send(:_timeout_settings))
       @accessibility = Accessibility.new(@channel)
       @keyboard = Keyboard.new(@channel)
       @mouse = Mouse.new(@channel)
       @touchscreen = Touchscreen.new(@channel)
 
       @viewport_size = @initializer['viewportSize']
+      @closed = false
       @main_frame = ChannelOwners::Frame.from(@initializer['mainFrame'])
       @main_frame.send(:update_page_from_page, self)
       @frames = Set.new
       @frames << @main_frame
+
+      @channel.once('close', ->(_) { on_close })
+      @channel.on('console', ->(params) {
+        console_message = ChannelOwners::ConsoleMessage.from(params['message'])
+        emit(Events::Page::Console, console_message)
+      })
+      @channel.on('domcontentloaded', ->(_) { emit(Events::Page::DOMContentLoaded) })
+      @channel.on('frameAttached', ->(params) {
+        on_frame_attached(ChannelOwners::Frame.from(params['frame']))
+      })
+      @channel.on('frameDetached', ->(params) {
+        on_frame_detached(ChannelOwners::Frame.from(params['frame']))
+      })
+      @channel.on('load', ->(_) { emit(Events::Page::Load) })
+      @channel.on('popup', ->(params) {
+        emit(Events::Page::Popup, ChannelOwners::Page.from(params['page']))
+      })
     end
 
     attr_reader \
@@ -26,6 +47,82 @@ module Playwright
       :viewport_size,
       :main_frame
 
+    private def on_frame_attached(frame)
+      frame.send(:update_page_from_page, self)
+      @frames << frame
+      emit(Events::Page::FrameAttached, frame)
+    end
+
+    private def on_frame_detached(frame)
+      @frames.delete(frame)
+      frame.detached = true
+      emit(Events::Page::FrameDetached, frame)
+    end
+
+    private def on_close
+      @closed = true
+      @browser_context.send(:remove_page, self)
+      emit(Events::Page::Close)
+    end
+
+    def context
+      @browser_context
+    end
+
+    def opener
+      resp = @channel.send_message_to_server('opener')
+      ChannelOwners::Page.from(resp)
+    end
+
+    def frame(frameSelector)
+      name, url =
+        if frameSelector.is_a?(Hash)
+          [frameSelector[:name], frameSelector[:url]]
+        else
+          [frameSelector, nil]
+        end
+
+      if name
+        @frames.find { |f| f.name == name }
+      elsif url
+        # ref: https://github.com/microsoft/playwright-python/blob/c4320c27cb080b385a5e45be46baa3cb7a9409ff/playwright/_impl/_helper.py#L104
+        case url
+        when String
+          @frames.find { |f| f.url == url }
+        when Regexp
+          @frames.find { |f| url.match?(f.url) }
+        else
+          raise NotImplementedError.new('Page#frame with url is not completely implemented yet')
+        end
+      else
+        raise ArgumentError.new('Either name or url matcher should be specified')
+      end
+    end
+
+    def frames
+      @frames.to_a
+    end
+
+    def evaluate(pageFunction, arg: nil)
+      @main_frame.evaluate(pageFunction, arg: arg)
+    end
+
+    def evaluate_handle(pageFunction, arg: nil)
+      @main_frame.evaluate_handle(pageFunction, arg: arg)
+    end
+
+    def url
+      @main_frame.url
+    end
+
+    def content
+      @main_frame.content
+    end
+
+    def set_content(html, timeout: nil, waitUntil: nil)
+      @main_frame.set_content(html, timeout: timeout, waitUntil: waitUntil)
+    end
+
     def goto(url, timeout: nil, waitUntil: nil, referer: nil)
       @main_frame.goto(url, timeout: timeout,  waitUntil: waitUntil, referer: referer)
     end
@@ -62,5 +159,126 @@ module Playwright
       end
       decoded_binary
     end
+
+    def title
+      @main_frame.title
+    end
+
+    def close(runBeforeUnload: nil)
+      options = { runBeforeUnload: runBeforeUnload }.compact
+      @channel.send_message_to_server('close', options)
+      @owned_context&.close
+      nil
+    rescue => err
+      raise unless safe_close_error?(err)
+    end
+
+    def closed?
+      @closed
+    end
+
+    def focus(selector, timeout: nil)
+      @main_frame.focus(selector, timeout: timeout)
+    end
+
+    def type_text(
+      selector,
+      text,
+      delay: nil,
+      noWaitAfter: nil,
+      timeout: nil)
+
+      @main_frame.type_text(selector, text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def press(
+      selector,
+      key,
+      delay: nil,
+      noWaitAfter: nil,
+      timeout: nil)
+
+      @main_frame.press(selector, key, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    class CrashedError < StandardError
+      def initialize
+        super('Page crashed')
+      end
+    end
+
+    class AlreadyClosedError < StandardError
+      def initialize
+        super('Page closed')
+      end
+    end
+
+    def wait_for_event(event, optionsOrPredicate: nil, &block)
+      predicate, timeout =
+        case optionsOrPredicate
+        when Proc
+          [optionsOrPredicate, nil]
+        when Hash
+          [optionsOrPredicate[:predicate], optionsOrPredicate[:timeout]]
+        else
+          [nil, nil]
+        end
+      timeout ||= @timeout_settings.timeout
+
+      wait_helper = WaitHelper.new
+      wait_helper.reject_on_timeout(timeout, "Timeout while waiting for event \"#{event}\"")
+
+      unless event == Events::Page::Crash
+        wait_helper.reject_on_event(self, Events::Page::Crash, CrashedError.new)
+      end
+
+      unless event == Events::Page::Close
+        wait_helper.reject_on_event(self, Events::Page::Close, AlreadyClosedError.new)
+      end
+
+      wait_helper.wait_for_event(self, event, predicate: predicate)
+
+      block&.call
+
+      wait_helper.promise.value!
+    end
+
+    def wait_for_request(urlOrPredicate, timeout: nil)
+      predicate =
+        case urlOrPredicate
+        when String
+          -> (req){ req.url == urlOrPredicate }
+        when Regexp
+          -> (req){ urlOrPredicate.match?(req.url) }
+        when Proc
+          urlOrPredicate
+        else
+          -> (_) { true }
+        end
+
+      wait_for_event(Events::Page::Request, optionsOrPredicate: { predicate: predicate, timeout: timeout})
+    end
+
+    def wait_for_response(urlOrPredicate, timeout: nil)
+      predicate =
+        case urlOrPredicate
+        when String
+          -> (res){ res.url == urlOrPredicate }
+        when Regexp
+          -> (res){ urlOrPredicate.match?(res.url) }
+        when Proc
+          urlOrPredicate
+        else
+          -> (_) { true }
+        end
+
+      wait_for_event(Events::Page::Response, optionsOrPredicate: { predicate: predicate, timeout: timeout})
+    end
+
+    # called from BrowserContext#on_page with send(:update_browser_context, page), so keep private.
+    private def update_browser_context(context)
+      @browser_context = context
+      @timeout_settings = TimeoutSettings.new(context.send(:_timeout_settings))
+    end
   end
 end