Class: Puppeteer::Browser

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

Defined Under Namespace

Classes: TargetAlreadyExistError, TargetNotExistError

Constant Summary collapse

EVENT_MAPPINGS = 
{
  disconnected: 'Events.Browser.Disconnected',
  targetcreated: 'Events.Browser.TargetCreated',
  targetchanged: 'Events.Browser.TargetChanged',
  targetdestroyed: 'Events.Browser.TargetDestroyed',
}

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(connection:, context_ids:, ignore_https_errors:, default_viewport:, process:, close_callback:) ⇒ Browser

Returns a new instance of Browser.

Parameters:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/puppeteer/browser.rb', line 35

def initialize(connection:, context_ids:, ignore_https_errors:, default_viewport:, process:, close_callback:)
  @ignore_https_errors = ignore_https_errors
  @default_viewport = default_viewport
  @process = process
  # @screenshot_task_queue = TaskQueue.new
  @connection = connection
  @close_callback = close_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
  @targets = {}
  @connection.on_event 'Events.Connection.Disconnected' do
    emit_event 'Events.Browser.Disconnected'
  end
  @connection.on_event 'Target.targetCreated', &method(:handle_target_created)
  @connection.on_event 'Target.targetDestroyed', &method(:handle_target_destroyed)
  @connection.on_event 'Target.targetInfoChanged', &method(:handle_target_info_changed)
end

Class Method Details

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

Parameters:



16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/puppeteer/browser.rb', line 16

def self.create(connection:, context_ids:, ignore_https_errors:, default_viewport:, process:, close_callback:)
  browser = Puppeteer::Browser.new(
    connection: connection,
    context_ids: context_ids,
    ignore_https_errors: ignore_https_errors,
    default_viewport: default_viewport,
    process: process,
    close_callback: close_callback,
  )
  connection.send_message('Target.setDiscoverTargets', discover: true)
  browser
end

Instance Method Details

#browser_contexts ⇒ Object 



85
86
87
 
# File 'lib/puppeteer/browser.rb', line 85

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

#close ⇒ Object 



256
257
258
259
 
# File 'lib/puppeteer/browser.rb', line 256

def close
  @close_callback.call
  disconnect
end

#connected? ⇒ Boolean

Returns:

  • (Boolean) 


265
266
267
 
# File 'lib/puppeteer/browser.rb', line 265

def connected?
  !@connection.closed?
end

#create_incognito_browser_context ⇒ Puppeteer::BrowserContext

Returns:



79
80
81
82
83
 
# File 'lib/puppeteer/browser.rb', line 79

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:



179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/puppeteer/browser.rb', line 179

def create_page_in_context(context_id)
  create_target_params = { url: 'about:blank' }
  if context_id
    create_target_params[:browserContextId] = context_id
  end
  result = @connection.send_message('Target.createTarget', **create_target_params)
  target_id = result['targetId']
  target = @targets[target_id]
  await target.initialized_promise
  await target.page
end

#default_browser_context ⇒ Puppeteer::BrowserContext

Returns:



90
91
92
 
# File 'lib/puppeteer/browser.rb', line 90

def default_browser_context
  @default_context
end

#disconnect ⇒ Object 



261
262
263
 
# File 'lib/puppeteer/browser.rb', line 261

def disconnect
  @connection.dispose
end

#dispose_context(context_id) ⇒ Object

Parameters:

  • context_id (String) 


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

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

#handle_target_created(event) ⇒ Object

Parameters:

  • event (!Protocol.Target.targetCreatedPayload) 


107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/puppeteer/browser.rb', line 107

def handle_target_created(event)
  target_info = Puppeteer::Target::TargetInfo.new(event['targetInfo'])
  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

  if @targets[target_info.target_id]
    raise TargetAlreadyExistError.new
  end
  target = Puppeteer::Target.new(
    target_info: target_info,
    browser_context: context,
    session_factory: -> { @connection.create_session(target_info) },
    ignore_https_errors: @ignore_https_errors,
    default_viewport: @default_viewport,
    screenshot_task_queue: @screenshot_task_queue,
  )
  #   assert(!this._targets.has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
  @targets[target_info.target_id] = target
  if await target.initialized_promise
    emit_event 'Events.Browser.TargetCreated', target
    context.emit_event 'Events.BrowserContext.TargetCreated', target
  end
end

#handle_target_destroyed(event) ⇒ Object

Parameters:

  • event ({targetId: string}) 


137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/puppeteer/browser.rb', line 137

def handle_target_destroyed(event)
  target_id = event['targetId']
  target = @targets[target_id]
  target.ignore_initialize_callback_promise
  @targets.delete(target_id)
  target.closed_callback
  if await target.initialized_promise
    emit_event 'Events.Browser.TargetDestroyed', target
    target.browser_context.emit_event 'Events.BrowserContext.TargetDestroyed', target
  end
end

#handle_target_info_changed(event) ⇒ Object

Parameters:

  • event (!Protocol.Target.targetInfoChangedPayload) 


156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/puppeteer/browser.rb', line 156

def handle_target_info_changed(event)
  target_info = Puppeteer::Target::TargetInfo.new(event['targetInfo'])
  target = @targets[target_info.target_id] or raise TargetNotExistError.new
  previous_url = target.url
  was_initialized = target.initialized?
  target.handle_target_info_changed(target_info)
  if was_initialized && previous_url != target.url
    emit_event 'Events.Browser.TargetChanged', target
    target.browser_context.emit_event 'Events.BrowserContext.TargetChanged', target
  end
end

#new_page ⇒ Object 



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

def new_page
  @default_context.new_page
end

#on(event_name, &block) ⇒ Object

Parameters:

  • event_name (Symbol) —

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



65
66
67
68
69
70
71
 
# File 'lib/puppeteer/browser.rb', line 65

def on(event_name, &block)
  unless EVENT_MAPPINGS.has_key?(event_name.to_sym)
    raise ArgumentError.new("Unknown event name: #{event_name}. Known events are #{EVENT_MAPPINGS.keys.join(", ")}")
  end

  add_event_listener(EVENT_MAPPINGS[event_name.to_sym], &block)
end

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

Returns:



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

def pages
  browser_contexts.flat_map(&:pages)
end

#process ⇒ Puppeteer::BrowserRunner::BrowserProcess

Returns:



74
75
76
 
# File 'lib/puppeteer/browser.rb', line 74

def process
  @process
end

#target ⇒ !Target

Returns:



198
199
200
 
# File 'lib/puppeteer/browser.rb', line 198

def target
  targets.first { |target| target.type == 'browser' }
end

#targets ⇒ !Array<!Target>

Returns:



192
193
194
 
# File 'lib/puppeteer/browser.rb', line 192

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

#user_agent ⇒ String

Returns:

  • (String) 


252
253
254
 
# File 'lib/puppeteer/browser.rb', line 252

def user_agent
  get_version.user_agent
end

#version ⇒ String

Returns:

  • (String) 


247
248
249
 
# File 'lib/puppeteer/browser.rb', line 247

def version
  get_version.product
end

#wait_for_target(predicate:, timeout: nil) ⇒ !Promise<!Target>

Parameters:

  • predicate (function(!Target):boolean)
  • options ({timeout?: number}=)

Returns:



210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/puppeteer/browser.rb', line 210

def wait_for_target(predicate:, timeout: nil)
  timeout_in_sec = (timeout || 30000).to_i / 1000.0
  existing_target = targets.first { |target| predicate.call(target) }
  return existing_target if existing_target

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

  begin
    if timeout_in_sec > 0
      Timeout.timeout(timeout_in_sec) do
        target_promise.value!
      end
    else
      target_promise.value!
    end
  ensure
    remove_event_listener(*event_listening_ids)
  end
end

#websocket_endpoint ⇒ String

Returns:

  • (String) 


169
170
171
 
# File 'lib/puppeteer/browser.rb', line 169

def websocket_endpoint
  @connection.url
end