playwright-ruby-client 0.0.3

data/lib/playwright/errors.rb

@@ -0,0 +1,35 @@
+module Playwright
+  class Error < StandardError
+    # 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(
+          message: error_payload['message'],
+          stack: error_payload['stack'].split("\n"),
+        )
+      else
+        new(
+          name: error_payload['name'],
+          message: error_payload['message'],
+          stack: error_payload['stack'].split("\n"),
+        )
+      end
+    end
+
+    # @param name [String]
+    # @param message [String]
+    # @param stack [Array<String>]
+    def initialize(name:, message:, stack:)
+      super("#{name}: #{message}")
+      @name = name
+      @message = message
+      @stack = stack
+    end
+  end
+
+  class TimeoutError < Error
+    def initialize(message:, stack:)
+      super(name: 'TimeoutError', message: message, stack: stack)
+    end
+  end
+end

data/lib/playwright/event_emitter.rb

@@ -0,0 +1,62 @@
+module Playwright
+  class EventEmitterCallback
+    def initialize(callback_proc)
+      @proc = callback_proc
+    end
+
+    def call(*args)
+      @proc.call(*args)
+      true
+    end
+  end
+
+  class EventEmitterOnceCallback < EventEmitterCallback
+    def call(*args)
+      @__result ||= super
+      true
+    end
+  end
+
+
+  # A subset of Events/EventEmitter in Node.js
+  module EventEmitter
+    # @param event [String]
+    def emit(event, *args)
+      (@__event_emitter ||= {})[event.to_s]&.each do |callback|
+        callback.call(*args)
+      end
+      self
+    end
+
+    # @param event [String]
+    # @param callback [Proc]
+    def on(event, callback)
+      raise ArgumentError.new('callback must not be nil') if callback.nil?
+      cb = (@__event_emitter_callback ||= {})["#{event}/#{callback.object_id}"] ||= EventEmitterCallback.new(callback)
+      ((@__event_emitter ||= {})[event.to_s] ||= Set.new) << cb
+      self
+    end
+
+    # @param event [String]
+    # @param callback [Proc]
+    def once(event, callback)
+      raise ArgumentError.new('callback must not be nil') if callback.nil?
+
+      cb = (@__event_emitter_callback ||= {})["#{event}/once/#{callback.object_id}"] ||= EventEmitterOnceCallback.new(callback)
+      ((@__event_emitter ||= {})[event.to_s] ||= Set.new) << cb
+      self
+    end
+
+    # @param event [String]
+    # @param callback [Proc]
+    def off(event, callback)
+      raise ArgumentError.new('callback must not be nil') if callback.nil?
+
+      cb = (@__event_emitter_callback ||= {})["#{event}/#{callback.object_id}"]
+      if cb
+        (@__event_emitter ||= {})[event.to_s]&.delete(cb)
+      end
+      self
+    end
+  end
+end

data/lib/playwright/events.rb

@@ -0,0 +1,86 @@
+module Playwright
+  module Events
+  end
+end
+
+# @see https://github.com/microsoft/playwright/blob/master/src/client/events.ts
+{
+  AndroidDevice: {
+    WebView: 'webview',
+    Close: 'close'
+  },
+
+  AndroidSocket: {
+    Data: 'data',
+    Close: 'close'
+  },
+
+  AndroidWebView: {
+    Close: 'close'
+  },
+
+  Browser: {
+    Disconnected: 'disconnected'
+  },
+
+  BrowserContext: {
+    Close: 'close',
+    Page: 'page',
+  },
+
+  BrowserServer: {
+    Close: 'close',
+  },
+
+  Page: {
+    Close: 'close',
+    Crash: 'crash',
+    Console: 'console',
+    Dialog: 'dialog',
+    Download: 'download',
+    FileChooser: 'filechooser',
+    DOMContentLoaded: 'domcontentloaded',
+    # Can't use just 'error' due to node.js special treatment of error events.
+    # @see https://nodejs.org/api/events.html#events_error_events
+    PageError: 'pageerror',
+    Request: 'request',
+    Response: 'response',
+    RequestFailed: 'requestfailed',
+    RequestFinished: 'requestfinished',
+    FrameAttached: 'frameattached',
+    FrameDetached: 'framedetached',
+    FrameNavigated: 'framenavigated',
+    Load: 'load',
+    Popup: 'popup',
+    WebSocket: 'websocket',
+    Worker: 'worker',
+  },
+
+  WebSocket: {
+    Close: 'close',
+    Error: 'socketerror',
+    FrameReceived: 'framereceived',
+    FrameSent: 'framesent',
+  },
+
+  Worker: {
+    Close: 'close',
+  },
+
+  ChromiumBrowserContext: {
+    BackgroundPage: 'backgroundpage',
+    ServiceWorker: 'serviceworker',
+  },
+
+  ElectronApplication: {
+    Close: 'close',
+    Window: 'window',
+  },
+}.each do |key, events|
+  events_module = Module.new
+  events.each do |event_key, event_value|
+    events_module.const_set(event_key, event_value)
+  end
+  events_module.define_singleton_method(:keys) { events.keys }
+  ::Playwright::Events.const_set(key, events_module)
+end

data/lib/playwright/playwright_api.rb

@@ -0,0 +1,75 @@
+module Playwright
+  class PlaywrightApi
+    # Wrap ChannelOwner.
+    # Playwright::ChannelOwners::XXXXX will be wrapped as Playwright::XXXXX
+    # Playwright::XXXXX is automatically generated by development/generate_api
+    #
+    # @param channel_owner [ChannelOwner]
+    # @note Intended for internal use only.
+    def self.from_channel_owner(channel_owner)
+      Factory.new(channel_owner).create
+    end
+
+    private
+
+    class Factory
+      def initialize(channel_owner)
+        channel_owner_class_name = channel_owner.class.name
+        raise "#{channel_owner_class_name} is not a channel owner" unless channel_owner_class_name.include?('::ChannelOwners::')
+
+        @channel_owner = channel_owner
+      end
+
+      def create
+        api_class = detect_class_for(@channel_owner.class)
+        if api_class
+          api_class.new(@channel_owner)
+        else
+          raise NotImplementedError.new("Playwright::#{expected_class_name_for(@channel_owner.class)} is not implemented")
+        end
+      end
+
+      private
+
+      def expected_class_name_for(klass)
+        klass.name.split('::ChannelOwners::').last
+      end
+
+      def detect_class_for(klass)
+        class_name = expected_class_name_for(klass)
+        if ::Playwright.const_defined?(class_name)
+          ::Playwright.const_get(class_name)
+        else
+          if [::Playwright::ChannelOwner, Object].include?(klass.superclass)
+            nil
+          else
+            detect_class_for(klass.superclass)
+          end
+        end
+      end
+    end
+
+    # @param channel_owner [Playwright::ChannelOwner]
+    def initialize(channel_owner)
+      @channel_owner = channel_owner
+    end
+
+    # @param block [Proc]
+    def wrap_block_call(block)
+      -> (*args) {
+        wrapped_args = args.map { |arg| wrap_channel_owner(arg) }
+        block.call(*wrapped_args)
+      }
+    end
+
+    def wrap_channel_owner(object)
+      if object.is_a?(ChannelOwner)
+        PlaywrightApi.from_channel_owner(object)
+      elsif object.is_a?(Array)
+        object.map { |obj| wrap_channel_owner(obj) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/playwright/transport.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require "stringio"
+
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_transport.py
+  class Transport
+    # @param playwright_cli_executable_path [String] path to playwright-cli.
+    # @param debug [Boolean]
+    def initialize(playwright_cli_executable_path:)
+      @driver_executable_path = playwright_cli_executable_path
+      @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+    end
+
+    def on_message_received(&block)
+      @on_message = 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
+      raise AlreadyDisconnectedError.new('send_message failed')
+    end
+
+    # Terminate playwright-cli driver.
+    def stop
+      [@stdin, @stdout, @stderr].each { |io| io.close unless io.closed? }
+    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')
+
+      Thread.new { handle_stdout }
+      Thread.new { handle_stderr }
+
+      @thread.join
+    end
+
+    private
+
+    def handle_stdout(packet_size: 32_768)
+      while chunk = @stdout.read(4)
+        length = chunk.unpack1('V') # unsigned 32bit, little endian
+        buffer = StringIO.new
+        (length / packet_size).to_i.times do
+          buffer << @stdout.read(packet_size)
+        end
+        buffer << @stdout.read(length % packet_size)
+        buffer.rewind
+        obj = JSON.parse(buffer.read)
+
+        debug_recv_message(obj) if @debug
+        @on_message&.call(obj)
+      end
+    rescue IOError
+      # disconnected by remote.
+    end
+
+    def handle_stderr
+      while err = @stderr.read
+        $stderr.write(err)
+      end
+    rescue IOError
+      # disconnected by remote.
+    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/version.rb

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

data/lib/playwright_api/accessibility.rb

@@ -0,0 +1,39 @@
+module Playwright
+  # The Accessibility class provides methods for inspecting Chromium's accessibility tree. The accessibility tree is used by assistive technology such as screen readers or switches.
+  # Accessibility is a very platform-specific thing. On different platforms, there are different screen readers that might have wildly different output.
+  # Blink - Chromium's rendering engine - has a concept of "accessibility tree", which is then translated into different platform-specific APIs. Accessibility namespace gives users access to the Blink Accessibility Tree.
+  # Most of the accessibility tree gets filtered out when converting from Blink AX Tree to Platform-specific AX-Tree or by assistive technologies themselves. By default, Playwright tries to approximate this filtering, exposing only the "interesting" nodes of the tree.
+  class Accessibility < PlaywrightApi
+
+    # Captures the current state of the accessibility tree. The returned object represents the root accessible node of the page.
+    # 
+    # **NOTE** The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen readers. Playwright will discard them as well for an easier to process tree, unless `interestingOnly` is set to `false`.
+    # 
+    # An example of dumping the entire accessibility tree:
+    #
+    # ```js
+    # const snapshot = await page.accessibility.snapshot();
+    # console.log(snapshot);
+    # ```
+    # An example of logging the focused node's name:
+    #
+    # ```js
+    # const snapshot = await page.accessibility.snapshot();
+    # const node = findFocusedNode(snapshot);
+    # console.log(node && node.name);
+    # 
+    # function findFocusedNode(node) {
+    #   if (node.focused)
+    #     return node;
+    #   for (const child of node.children || []) {
+    #     const foundNode = findFocusedNode(child);
+    #     return foundNode;
+    #   }
+    #   return null;
+    # }
+    # ```
+    def snapshot(interestingOnly: nil, root: nil)
+      raise NotImplementedError.new('snapshot is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/binding_call.rb

@@ -0,0 +1,5 @@
+module Playwright
+  # @nodoc
+  class BindingCall < PlaywrightApi
+  end
+end

data/lib/playwright_api/browser.rb

@@ -0,0 +1,123 @@
+module Playwright
+  # A Browser is created when Playwright connects to a browser instance, either through `browserType.launch([options])` or `browserType.connect(params)`.
+  # An example of using a Browser to create a Page:
+  #
+  # ```js
+  # const { firefox } = require('playwright');  // Or 'chromium' or 'webkit'.
+  # 
+  # (async () => {
+  #   const browser = await firefox.launch();
+  #   const page = await browser.newPage();
+  #   await page.goto('https://example.com');
+  #   await browser.close();
+  # })();
+  # ```
+  # See ChromiumBrowser, FirefoxBrowser and WebKitBrowser for browser-specific features. Note that `browserType.connect(params)` and `browserType.launch([options])` always return a specific browser instance, based on the browser being connected to or launched.
+  class Browser < PlaywrightApi
+
+    # In case this browser is obtained using `browserType.launch([options])`, closes the browser and all of its pages (if any were opened).
+    # In case this browser is obtained using `browserType.connect(params)`, clears all created contexts belonging to this browser and disconnects from the browser server.
+    # The Browser object itself is considered to be disposed and cannot be used anymore.
+    def close
+      wrap_channel_owner(@channel_owner.close)
+    end
+
+    # Returns an array of all open browser contexts. In a newly created browser, this will return zero browser contexts.
+    #
+    # ```js
+    # const browser = await pw.webkit.launch();
+    # console.log(browser.contexts().length); // prints `0`
+    # 
+    # const context = await browser.newContext();
+    # console.log(browser.contexts().length); // prints `1`
+    # ```
+    def contexts
+      wrap_channel_owner(@channel_owner.contexts)
+    end
+
+    # Indicates that the browser is connected.
+    def connected?
+      wrap_channel_owner(@channel_owner.connected?)
+    end
+
+    # Creates a new browser context. It won't share cookies/cache with other browser contexts.
+    #
+    # ```js
+    # (async () => {
+    #   const browser = await playwright.firefox.launch();  // Or 'chromium' or 'webkit'.
+    #   // Create a new incognito browser context.
+    #   const context = await browser.newContext();
+    #   // Create a new page in a pristine context.
+    #   const page = await context.newPage();
+    #   await page.goto('https://example.com');
+    # })();
+    # ```
+    def new_context(
+          acceptDownloads: nil,
+          ignoreHTTPSErrors: nil,
+          bypassCSP: nil,
+          viewport: nil,
+          userAgent: nil,
+          deviceScaleFactor: nil,
+          isMobile: nil,
+          hasTouch: nil,
+          javaScriptEnabled: nil,
+          timezoneId: nil,
+          geolocation: nil,
+          locale: nil,
+          permissions: nil,
+          extraHTTPHeaders: nil,
+          offline: nil,
+          httpCredentials: nil,
+          colorScheme: nil,
+          logger: nil,
+          videosPath: nil,
+          videoSize: nil,
+          recordHar: nil,
+          recordVideo: nil,
+          proxy: nil,
+          storageState: nil)
+      wrap_channel_owner(@channel_owner.new_context(acceptDownloads: acceptDownloads, ignoreHTTPSErrors: ignoreHTTPSErrors, bypassCSP: bypassCSP, viewport: viewport, userAgent: userAgent, deviceScaleFactor: deviceScaleFactor, isMobile: isMobile, hasTouch: hasTouch, javaScriptEnabled: javaScriptEnabled, timezoneId: timezoneId, geolocation: geolocation, locale: locale, permissions: permissions, extraHTTPHeaders: extraHTTPHeaders, offline: offline, httpCredentials: httpCredentials, colorScheme: colorScheme, logger: logger, videosPath: videosPath, videoSize: videoSize, recordHar: recordHar, recordVideo: recordVideo, proxy: proxy, storageState: storageState))
+    end
+
+    # Creates a new page in a new browser context. Closing this page will close the context as well.
+    # This is a convenience API that should only be used for the single-page scenarios and short snippets. Production code and testing frameworks should explicitly create `browser.newContext([options])` followed by the `browserContext.newPage()` to control their exact life times.
+    def new_page(
+          acceptDownloads: nil,
+          ignoreHTTPSErrors: nil,
+          bypassCSP: nil,
+          viewport: nil,
+          userAgent: nil,
+          deviceScaleFactor: nil,
+          isMobile: nil,
+          hasTouch: nil,
+          javaScriptEnabled: nil,
+          timezoneId: nil,
+          geolocation: nil,
+          locale: nil,
+          permissions: nil,
+          extraHTTPHeaders: nil,
+          offline: nil,
+          httpCredentials: nil,
+          colorScheme: nil,
+          logger: nil,
+          videosPath: nil,
+          videoSize: nil,
+          recordHar: nil,
+          recordVideo: nil,
+          proxy: nil,
+          storageState: nil)
+      wrap_channel_owner(@channel_owner.new_page(acceptDownloads: acceptDownloads, ignoreHTTPSErrors: ignoreHTTPSErrors, bypassCSP: bypassCSP, viewport: viewport, userAgent: userAgent, deviceScaleFactor: deviceScaleFactor, isMobile: isMobile, hasTouch: hasTouch, javaScriptEnabled: javaScriptEnabled, timezoneId: timezoneId, geolocation: geolocation, locale: locale, permissions: permissions, extraHTTPHeaders: extraHTTPHeaders, offline: offline, httpCredentials: httpCredentials, colorScheme: colorScheme, logger: logger, videosPath: videosPath, videoSize: videoSize, recordHar: recordHar, recordVideo: recordVideo, proxy: proxy, storageState: storageState))
+    end
+
+    # Returns the browser version.
+    def version
+      wrap_channel_owner(@channel_owner.version)
+    end
+
+    # @nodoc
+    def after_initialize
+      wrap_channel_owner(@channel_owner.after_initialize)
+    end
+  end
+end