Class: Puppeteer::Browser

Inherits:
Object
  • Object
show all
Includes:
DebugPrint, EventCallbackable, IfPresent
Defined in:
lib/puppeteer/browser.rb

Defined Under Namespace

Classes: CreatePageError, MissingBrowserContextError, MissingTargetError, Version

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from IfPresent

#if_present

Methods included from EventCallbackable

#add_event_listener, #emit_event, #observe_first, #on_event, #remove_event_listener

Methods included from DebugPrint

#debug_print, #debug_puts

Constructor Details

#initialize(product:, connection:, context_ids:, ignore_https_errors:, default_viewport:, process:, close_callback:, target_filter_callback:, is_page_target_callback:) ⇒ Browser

Returns a new instance of Browser.

Parameters:

  • product (String|nil) —

    ‘chrome’ or ‘firefox’

  • connection (!Puppeteer.Connection)
  • contextIds (!Array<string>)
  • ignoreHTTPSErrors (boolean)
  • defaultViewport (?Puppeteer.Viewport)
  • process (?Puppeteer.ChildProcess)
  • closeCallback ((function():Promise)=) 


48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/puppeteer/browser.rb', line 48

def initialize(product:,
               connection:,
               context_ids:,
               ignore_https_errors:,
               default_viewport:,
               process:,
               close_callback:,
               target_filter_callback:,
               is_page_target_callback:)
  @product = product || 'chrome'
  @ignore_https_errors = ignore_https_errors
  @default_viewport = default_viewport
  @process = process
  @connection = connection
  @close_callback = close_callback
  @target_filter_callback = target_filter_callback || method(:default_target_filter_callback)
  @is_page_target_callback = is_page_target_callback || method(:default_is_page_target_callback)
  @default_context = Puppeteer::BrowserContext.new(@connection, self, nil)
  @contexts = {}

  context_ids.each do |context_id|
    @contexts[context_id] = Puppeteer::BrowserContext.new(@connection, self, context_id)
  end

  if @product == 'firefox'
    @target_manager = Puppeteer::FirefoxTargetManager.new(
      connection: connection,
      target_factory: method(:create_target),
      target_filter_callback: @target_filter_callback,
    )
  else
    @target_manager = Puppeteer::ChromeTargetManager.new(
      connection: connection,
      target_factory: method(:create_target),
      target_filter_callback: @target_filter_callback,
    )
  end
end

Instance Attribute Details

#is_page_target_callback ⇒ Object (readonly)

Returns the value of attribute is_page_target_callback.



95
96
97
 
# File 'lib/puppeteer/browser.rb', line 95

def is_page_target_callback
  @is_page_target_callback
end

Class Method Details

.create(product:, connection:, context_ids:, ignore_https_errors:, default_viewport:, process:, close_callback:, target_filter_callback:, is_page_target_callback:) ⇒ Object

Parameters:



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/puppeteer/browser.rb', line 17

def self.create(product:,
                connection:,
                context_ids:,
                ignore_https_errors:,
                default_viewport:,
                process:,
                close_callback:,
                target_filter_callback:,
                is_page_target_callback:)
  browser = Puppeteer::Browser.new(
    product: product,
    connection: connection,
    context_ids: context_ids,
    ignore_https_errors: ignore_https_errors,
    default_viewport: default_viewport,
    process: process,
    close_callback: close_callback,
    target_filter_callback: target_filter_callback,
    is_page_target_callback: is_page_target_callback,
  )
  browser.send(:attach)
  browser
end

Instance Method Details

#async_wait_for_target(predicate: , timeout: nil) ⇒ Object

Parameters:



320
 
# File 'lib/puppeteer/browser.rb', line 320

define_async_method :async_wait_for_target

#browser_contexts ⇒ Object 



161
162
163
 
# File 'lib/puppeteer/browser.rb', line 161

def browser_contexts
  [@default_context].concat(@contexts.values)
end

#close ⇒ Object 



337
338
339
340
 
# File 'lib/puppeteer/browser.rb', line 337

def close
  @close_callback.call
  disconnect
end

#connected? ⇒ Boolean

Returns:

  • (Boolean) 


347
348
349
 
# File 'lib/puppeteer/browser.rb', line 347

def connected?
  !@connection.closed?
end

#create_incognito_browser_context ⇒ Puppeteer::BrowserContext

Returns:



155
156
157
158
159
 
# File 'lib/puppeteer/browser.rb', line 155

def create_incognito_browser_context
  result = @connection.send_message('Target.createBrowserContext')
  browser_context_id = result['browserContextId']
  @contexts[browser_context_id] = Puppeteer::BrowserContext.new(@connection, self, browser_context_id)
end

#create_page_in_context(context_id) ⇒ !Promise<!Puppeteer.Page>

Parameters:

  • contextId (?string)

Returns:



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/puppeteer/browser.rb', line 250

def create_page_in_context(context_id)
  create_target_params = {
    url: 'about:blank',
    browserContextId: context_id,
  }.compact
  result = @connection.send_message('Target.createTarget', **create_target_params)
  target_id = result['targetId']
  target = @target_manager.available_targets[target_id]
  unless target
    raise MissingTargetError.new("Missing target for page (id = #{target_id})")
  end
  unless target.initialized_promise.value!
    raise CreatePageError.new("Failed to create target for page (id = #{target_id})")
  end
  page = target.page
  unless page
    raise CreatePageError.new("Failed to create a page for context (id = #{context_id})")
  end
  page
end

#create_target(target_info, session) ⇒ Object

Parameters:



181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/puppeteer/browser.rb', line 181

def create_target(target_info, session)
  browser_context_id = target_info.browser_context_id
  context =
    if browser_context_id && @contexts.has_key?(browser_context_id)
      @contexts[browser_context_id]
    else
      @default_context
    end

  unless context
    raise MissingBrowserContextError.new('Missing browser context')
  end

  Puppeteer::Target.new(
    target_info: target_info,
    session: session,
    browser_context: context,
    target_manager: @target_manager,
    session_factory: -> (auto_attach_emulated) { @connection.create_session(target_info, auto_attach_emulated: auto_attach_emulated) },
    ignore_https_errors: @ignore_https_errors,
    default_viewport: @default_viewport,
    is_page_target_callback: @is_page_target_callback,
  )
end

#default_browser_context ⇒ Puppeteer::BrowserContext

Returns:



166
167
168
 
# File 'lib/puppeteer/browser.rb', line 166

def default_browser_context
  @default_context
end

#disconnect ⇒ Object 



342
343
344
345
 
# File 'lib/puppeteer/browser.rb', line 342

def disconnect
  @target_manager.dispose
  @connection.dispose
end

#dispose_context(context_id) ⇒ Object

Parameters:

  • context_id (String) 


171
172
173
174
175
 
# File 'lib/puppeteer/browser.rb', line 171

def dispose_context(context_id)
  return unless context_id
  @connection.send_message('Target.disposeBrowserContext', browserContextId: context_id)
  @contexts.delete(context_id)
end

#new_page ⇒ Object 



241
242
243
 
# File 'lib/puppeteer/browser.rb', line 241

def new_page
  @default_context.new_page
end

#on(event_name, &block) ⇒ Object

Parameters:

  • event_name (Symbol) —

    either of :disconnected, :targetcreated, :targetchanged, :targetdestroyed



98
99
100
101
102
103
104
 
# File 'lib/puppeteer/browser.rb', line 98

def on(event_name, &block)
  unless BrowserEmittedEvents.values.include?(event_name.to_s)
    raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{BrowserEmittedEvents.values.to_a.join(", ")}")
  end

  super(event_name.to_s, &block)
end

#once(event_name, &block) ⇒ Object

Parameters:

  • event_name (Symbol) 


107
108
109
110
111
112
113
 
# File 'lib/puppeteer/browser.rb', line 107

def once(event_name, &block)
  unless BrowserEmittedEvents.values.include?(event_name.to_s)
    raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{BrowserEmittedEvents.values.to_a.join(", ")}")
  end

  super(event_name.to_s, &block)
end

#pages ⇒ !Promise<!Array<!Puppeteer.Page>>

Returns:



323
324
325
 
# File 'lib/puppeteer/browser.rb', line 323

def pages
  browser_contexts.flat_map(&:pages)
end

#process ⇒ Puppeteer::BrowserRunner::BrowserProcess

Returns:



146
147
148
 
# File 'lib/puppeteer/browser.rb', line 146

def process
  @process
end

#target ⇒ Object

The target associated with the browser.



279
280
281
 
# File 'lib/puppeteer/browser.rb', line 279

def target
  targets.find { |target| target.type == 'browser' } or raise 'Browser target is not found'
end

#targets ⇒ Object

All active targets inside the Browser. In case of multiple browser contexts, returns an array with all the targets in all browser contexts.



273
274
275
 
# File 'lib/puppeteer/browser.rb', line 273

def targets
  @target_manager.available_targets.values.select { |target| target.initialized? }
end

#user_agent ⇒ String

Returns:

  • (String) 


333
334
335
 
# File 'lib/puppeteer/browser.rb', line 333

def user_agent
  Version.fetch(@connection).user_agent
end

#version ⇒ String

Returns:

  • (String) 


328
329
330
 
# File 'lib/puppeteer/browser.rb', line 328

def version
  Version.fetch(@connection).product
end

#wait_for_target(predicate:, timeout: nil) ⇒ Puppeteer::Target

Parameters:

Returns:



290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
 
# File 'lib/puppeteer/browser.rb', line 290

def wait_for_target(predicate:, timeout: nil)
  timeout_helper = Puppeteer::TimeoutHelper.new('target', timeout_ms: timeout, default_timeout_ms: 30000)
  existing_target = targets.find { |target| predicate.call(target) }
  return existing_target if existing_target

  event_listening_ids = []
  target_promise = resolvable_future
  event_listening_ids << add_event_listener(BrowserEmittedEvents::TargetCreated) do |target|
    if predicate.call(target)
      target_promise.fulfill(target)
    end
  end
  event_listening_ids << add_event_listener(BrowserEmittedEvents::TargetChanged) do |target|
    if predicate.call(target)
      target_promise.fulfill(target)
    end
  end

  begin
    timeout_helper.with_timeout do
      target_promise.value!
    end
  ensure
    remove_event_listener(*event_listening_ids)
  end
end

#ws_endpoint ⇒ String

Returns:

  • (String) 


237
238
239
 
# File 'lib/puppeteer/browser.rb', line 237

def ws_endpoint
  @connection.url
end