playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/channel_owners/artifact.rb

@@ -0,0 +1,40 @@
+require 'stringio'
+
+module Playwright
+  define_channel_owner :Artifact do
+    private def after_initialize
+      @absolute_path = @initializer['absolutePath']
+    end
+
+    attr_reader :absolute_path
+
+    def path_after_finished
+      if @connection.remote?
+        raise "Path is not available when using browser_type.connect(). Use save_as() to save a local copy."
+      end
+      @channel.send_message_to_server('pathAfterFinished')
+    end
+
+    def save_as(path)
+      stream = ChannelOwners::Stream.from(@channel.send_message_to_server('saveAsStream'))
+      stream.save_as(path)
+    end
+
+    def read_into_buffer
+      stream = ChannelOwners::Stream.from(@channel.send_message_to_server('stream'))
+      stream.read_all
+    end
+
+    def failure
+      @channel.send_message_to_server('failure')
+    end
+
+    def delete
+      @channel.send_message_to_server('delete')
+    end
+
+    def cancel
+      @channel.send_message_to_server('cancel')
+    end
+  end
+end

data/lib/playwright/channel_owners/binding_call.rb

@@ -1,4 +1,74 @@
 module Playwright
   define_channel_owner :BindingCall do
+    class << self
+      def call_queue
+        @call_queue ||= Queue.new
+      end
+
+      def worker_mutex
+        @worker_mutex ||= Mutex.new
+      end
+
+      def ensure_worker
+        worker_mutex.synchronize do
+          return if @worker&.alive?
+
+          @worker = Thread.new do
+            loop do
+              job = call_queue.pop
+              begin
+                job.call
+              rescue => err
+                $stderr.write("BindingCall worker error: #{err.class}: #{err.message}\n")
+                err.backtrace&.each { |line| $stderr.write("#{line}\n") }
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def name
+      @initializer['name']
+    end
+
+    def call_async(callback)
+      # Binding callbacks can be fired concurrently from multiple threads.
+      # Enqueue and execute them on a single worker thread so we:
+      # - preserve the delivery order of binding calls
+      # - avoid spawning a thread per call (bursty timers create many callbacks)
+      # - keep the protocol dispatch thread unblocked
+      self.class.ensure_worker
+      self.class.call_queue << -> { call(callback) }
+    end
+
+    # @param callback [Proc]
+    def call(callback)
+      frame = ChannelOwners::Frame.from(@initializer['frame'])
+      # It is not desired to use PlaywrightApi.wrap directly.
+      # However it is a little difficult to define wrapper for `source` parameter in generate_api.
+      # Just a workaround...
+      source = {
+        context: PlaywrightApi.wrap(frame.page.context),
+        page: PlaywrightApi.wrap(frame.page),
+        frame: PlaywrightApi.wrap(frame),
+      }
+      args =
+        if @initializer['handle']
+          handle = ChannelOwners::ElementHandle.from(@initializer['handle'])
+          [handle]
+        else
+          @initializer['args'].map do |arg|
+            JavaScript::ValueParser.new(arg).parse
+          end
+        end
+
+      begin
+        result = PlaywrightApi.unwrap(callback.call(source, *args))
+        @channel.async_send_message_to_server('resolve', result: JavaScript::ValueSerializer.new(result).serialize)
+      rescue => err
+        @channel.async_send_message_to_server('reject', error: { error: { message: err.message, name: 'Error' }})
+      end
+    end
   end
 end

data/lib/playwright/channel_owners/browser.rb

@@ -1,68 +1,160 @@
+require 'fileutils'
+
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser.py
   define_channel_owner :Browser do
-    include Utils::Errors::SafeCloseError
+    include Utils::Errors::TargetClosedErrorMethods
     include Utils::PrepareBrowserContextOptions
 
-    def after_initialize
+    private def after_initialize
+      @connected = true
+      @should_close_connection_on_close = false
+
       @contexts = Set.new
+      @channel.on('context', ->(params) { did_create_context(ChannelOwners::BrowserContext.from(params['context'])) })
       @channel.on('close', method(:on_close))
+      @close_reason = nil
+    end
+
+    private def close_reason
+      @close_reason
     end
 
     def contexts
       @contexts.to_a
     end
 
+    def browser_type
+      @browser_type
+    end
+
     def connected?
       @connected
     end
 
     def new_context(**options, &block)
       params = options.dup
+      @browser_type.send(:update_with_playwright_selectors_options, params)
       prepare_browser_context_options(params)
 
       resp = @channel.send_message_to_server('newContext', params.compact)
       context = ChannelOwners::BrowserContext.from(resp)
-      @contexts << context
-      context.browser = self
-      context.options = params
+      context.send(:initialize_har_from_options,
+        record_har_content: params[:record_har_content],
+        record_har_mode: params[:record_har_mode],
+        record_har_omit_content: params[:record_har_omit_content],
+        record_har_path: params[:record_har_path],
+        record_har_url_filter: params[:record_har_url_filter],
+      )
+      @browser_type.send(:did_create_context, context, params)
+      return context unless block
 
-      if block
-        begin
-          block.call(context)
-        ensure
-          context.close
-        end
-      else
-        context
+      begin
+        block.call(context)
+      ensure
+        context.close
       end
     end
 
-    def new_page(**options)
+    def new_page(**options, &block)
       context = new_context(**options)
       page = context.new_page
       page.owned_context = context
       context.owner_page = page
-      page
+
+      return page unless block
+
+      begin
+        block.call(page)
+      ensure
+        page.close
+      end
     end
 
-    def close
-      return if @closed_or_closing
-      @closed_or_closing = true
-      @channel.send_message_to_server('close')
+    def close(reason: nil)
+      @close_reason = reason
+      if @should_close_connection_on_close
+        @connection.stop
+      else
+        @channel.send_message_to_server('close', { reason: reason }.compact)
+      end
       nil
     rescue => err
-      raise unless safe_close_error?(err)
+      raise unless target_closed_error?(err)
     end
 
     def version
       @initializer['version']
     end
 
+    def new_browser_cdp_session
+      resp = @channel.send_message_to_server('newBrowserCDPSession')
+      ChannelOwners::CDPSession.from(resp)
+    end
+
+    def start_tracing(page: nil, categories: nil, path: nil, screenshots: nil)
+      params = {
+        page: page&.channel,
+        categories: categories,
+        screenshots: screenshots,
+      }.compact
+      @cr_tracing_path = path
+
+      @channel.send_message_to_server('startTracing', params)
+    end
+
+    def stop_tracing
+      artifact = ChannelOwners::Artifact.from(@channel.send_message_to_server("stopTracing"))
+      data = artifact.read_into_buffer
+      if @cr_tracing_path
+        File.dirname(@cr_tracing_path).tap do |dir|
+          FileUtils.mkdir_p(dir) unless File.exist?(dir)
+        end
+        File.open(@cr_tracing_path, 'wb') { |f| f.write(data) }
+      end
+      data
+    end
+
+    # called from BrowserType
+    private def connect_to_browser_type(browser_type, traces_dir)
+      # Note: when using connect(), `browserType` is different from `this.parent`.
+      # This is why browser type is not wired up in the constructor, and instead this separate method is called later on.
+      @browser_type = browser_type
+      @traces_dir = traces_dir
+      @contexts.each do |context|
+        setup_browser_context(context)
+      end
+    end
+
+    private def did_create_context(context)
+      context.browser = self
+      @contexts << context
+
+      # Note: when connecting to a browser, initial contexts arrive before `_browserType` is set,
+      # and will be configured later in `ConnectToBrowserType`.
+      if @browser_type
+        setup_browser_context(context)
+      end
+    end
+
+    private def setup_browser_context(context)
+      context.tracing.send(:update_traces_dir, @traces_dir)
+      @browser_type.send(:playwright_selectors_browser_contexts) << context
+    end
+
     private def on_close(_ = {})
       @connected = false
-      emit(Events::Browser::Disconnected)
-      @closed_or_closing = false
+      emit(Events::Browser::Disconnected, self)
+      @closed_or_closing = true
+    end
+
+    # called from BrowserContext#initialize
+    private def add_context(context)
+      @contexts << context
+    end
+
+    private def should_close_connection_on_close!
+      @should_close_connection_on_close = true
     end
 
     # called from BrowserContext#on_close with send(:remove_context), so keep private.