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, #off, #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:, network_enabled: true, issues_enabled: true, block_list: nil, process:, close_callback:, target_filter_callback:, is_page_target_callback:) ⇒ Browser

Returns a new instance of Browser.



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/puppeteer/browser.rb', line 67

def initialize(product:,
               connection:,
               context_ids:,
               ignore_https_errors:,
               default_viewport:,
               network_enabled: true,
               issues_enabled: true,
               block_list: nil,
               process:,
               close_callback:,
               target_filter_callback:,
               is_page_target_callback:)
  @product = product ? product.to_s : 'chrome'
  if @product != 'chrome'
    raise ArgumentError.new("Unsupported product: #{@product}. Only 'chrome' is supported.")
  end
  @ignore_https_errors = ignore_https_errors
  @default_viewport = default_viewport
  @network_enabled = network_enabled
  @issues_enabled = issues_enabled
  @block_list = block_list
  @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

  @target_manager = Puppeteer::ChromeTargetManager.new(
    connection: connection,
    target_factory: method(:create_target),
    target_filter_callback: @target_filter_callback,
    block_list: block_list,
  )
  @extensions = {}
end

Instance Attribute Details

#is_page_target_callback ⇒ Object (readonly)

Returns the value of attribute is_page_target_callback.



117
118
119
 
# File 'lib/puppeteer/browser.rb', line 117

def is_page_target_callback
  @is_page_target_callback
end

Class Method Details

.create(product:, connection:, context_ids:, ignore_https_errors:, default_viewport:, network_enabled: true, issues_enabled: true, block_list: nil, process:, close_callback:, target_filter_callback:, is_page_target_callback:) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/puppeteer/browser.rb', line 24

def self.create(product:,
                connection:,
                context_ids:,
                ignore_https_errors:,
                default_viewport:,
                network_enabled: true,
                issues_enabled: true,
                block_list: nil,
                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,
    network_enabled: network_enabled,
    issues_enabled: issues_enabled,
    block_list: block_list,
    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

#_has_devtools_target(page_target_id) ⇒ Object 



399
400
401
402
 
# File 'lib/puppeteer/browser.rb', line 399

def _has_devtools_target(page_target_id)
  result = @connection.send_message('Target.getDevToolsTarget', targetId: page_target_id)
  result['targetId']
end

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



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

define_async_method :async_wait_for_target

#block_list ⇒ Object 



450
451
452
 
# File 'lib/puppeteer/browser.rb', line 450

def block_list
  @block_list
end

#browser_contexts ⇒ Object 



208
209
210
 
# File 'lib/puppeteer/browser.rb', line 208

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

#close ⇒ Object 



455
456
457
458
 
# File 'lib/puppeteer/browser.rb', line 455

def close
  @close_callback.call
  disconnect
end

#connected? ⇒ Boolean

Returns:

  • (Boolean) 


467
468
469
 
# File 'lib/puppeteer/browser.rb', line 467

def connected?
  !@connection.closed?
end

#create_browser_context(proxy_server: nil, proxy_bypass_list: nil, download_behavior: nil) ⇒ Object 



195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/puppeteer/browser.rb', line 195

def create_browser_context(proxy_server: nil, proxy_bypass_list: nil, download_behavior: nil)
  params = {
    proxyServer: proxy_server,
    proxyBypassList: proxy_bypass_list&.join(','),
  }.compact
  result = @connection.send_message('Target.createBrowserContext', params)
  browser_context_id = result['browserContextId']
  context = Puppeteer::BrowserContext.new(@connection, self, browser_context_id)
  context.set_download_behavior(download_behavior) if download_behavior
  @contexts[browser_context_id] = context
end

#create_incognito_browser_context ⇒ Object 



185
186
187
188
189
 
# File 'lib/puppeteer/browser.rb', line 185

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) ⇒ Object 



308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/puppeteer/browser.rb', line 308

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.wait
    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 



237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
 
# File 'lib/puppeteer/browser.rb', line 237

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,
    network_enabled: @network_enabled,
    is_page_target_callback: @is_page_target_callback,
  )
end

#default_browser_context ⇒ Object 



213
214
215
 
# File 'lib/puppeteer/browser.rb', line 213

def default_browser_context
  @default_context
end

#disconnect ⇒ Object 



461
462
463
464
 
# File 'lib/puppeteer/browser.rb', line 461

def disconnect
  @target_manager.dispose
  @connection.dispose
end

#dispose_context(context_id) ⇒ Object 



226
227
228
229
230
 
# File 'lib/puppeteer/browser.rb', line 226

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

#extensions ⇒ Object 



421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
 
# File 'lib/puppeteer/browser.rb', line 421

def extensions
  response = @connection.send_message('Extensions.getExtensions')
  extension_map = {}
  response.fetch('extensions', []).each do |payload|
    extension_id = payload['id']
    existing_extension = @extensions[extension_id]
    extension_map[extension_id] =
      if existing_extension
        existing_extension
      else
        Puppeteer::Extension.new(
          id: extension_id,
          version: payload['version'],
          name: payload['name'],
          path: payload['path'],
          enabled: payload['enabled'],
          browser: self,
        )
      end
  end
  @extensions = extension_map
end

#install_extension(path) ⇒ Object 



406
407
408
409
410
411
 
# File 'lib/puppeteer/browser.rb', line 406

def install_extension(path)
  result = @connection.send_message('Extensions.loadUnpacked', path: path)
  extension_id = result['id']
  @extensions.delete(extension_id)
  extension_id
end

#issues_enabled? ⇒ Boolean

Returns:

  • (Boolean) 


445
446
447
 
# File 'lib/puppeteer/browser.rb', line 445

def issues_enabled?
  @issues_enabled
end

#new_page ⇒ Object 



299
300
301
 
# File 'lib/puppeteer/browser.rb', line 299

def new_page
  @default_context.new_page
end

#on(event_name, &block) ⇒ Object 



122
123
124
125
126
127
128
 
# File 'lib/puppeteer/browser.rb', line 122

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 



133
134
135
136
137
138
139
 
# File 'lib/puppeteer/browser.rb', line 133

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 ⇒ Object 



383
384
385
 
# File 'lib/puppeteer/browser.rb', line 383

def pages
  browser_contexts.flat_map(&:pages)
end

#process ⇒ Object 



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

def process
  @process
end

#set_permission(origin, *permissions) ⇒ Object 



220
221
222
 
# File 'lib/puppeteer/browser.rb', line 220

def set_permission(origin, *permissions)
  @default_context.set_permission(origin, *permissions)
end

#target ⇒ Object

The target associated with the browser.



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

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.



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

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

#uninstall_extension(extension_id) ⇒ Object 



415
416
417
418
 
# File 'lib/puppeteer/browser.rb', line 415

def uninstall_extension(extension_id)
  @connection.send_message('Extensions.uninstall', id: extension_id)
  @extensions.delete(extension_id)
end

#user_agent ⇒ Object 



393
394
395
 
# File 'lib/puppeteer/browser.rb', line 393

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

#version ⇒ Object 



388
389
390
 
# File 'lib/puppeteer/browser.rb', line 388

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

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



351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
 
# File 'lib/puppeteer/browser.rb', line 351

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 = Async::Promise.new
  event_listening_ids << add_event_listener(BrowserEmittedEvents::TargetCreated) do |target|
    if predicate.call(target)
      target_promise.resolve(target)
    end
  end
  event_listening_ids << add_event_listener(BrowserEmittedEvents::TargetChanged) do |target|
    if predicate.call(target)
      target_promise.resolve(target)
    end
  end

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

#ws_endpoint ⇒ Object 



294
295
296
 
# File 'lib/puppeteer/browser.rb', line 294

def ws_endpoint
  @connection.url
end