Class: Puppeteer::Page

Inherits:
Object
  • Object
show all
Includes:
EventCallbackable, IfPresent
Defined in:
lib/puppeteer/page.rb,
lib/puppeteer/page/pdf_options.rb,
lib/puppeteer/page/screenshot_options.rb,
lib/puppeteer/page/screenshot_task_queue.rb

Defined Under Namespace

Classes: FileChooserTimeoutError, JavaScriptExpression, JavaScriptFunction, PDFOptions, PageError, PrintToPdfIsNotImplementedError, ScreenshotOptions, ScreenshotTaskQueue, TargetCrashedError

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

Constructor Details

#initialize(client, target, ignore_https_errors) ⇒ Page 



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/puppeteer/page.rb', line 31

def initialize(client, target, ignore_https_errors)
  @closed = false
  @client = client
  @target = target
  @keyboard = Puppeteer::Keyboard.new(client)
  @mouse = Puppeteer::Mouse.new(client, @keyboard)
  @timeout_settings = Puppeteer::TimeoutSettings.new
  @touchscreen = Puppeteer::TouchScreen.new(client, @keyboard)
  # @accessibility = Accessibility.new(client)
  @frame_manager = Puppeteer::FrameManager.new(client, self, ignore_https_errors, @timeout_settings)
  @emulation_manager = Puppeteer::EmulationManager.new(client)
  @tracing = Puppeteer::Tracing.new(client)
  @page_bindings = {}
  @coverage = Puppeteer::Coverage.new(client)
  @javascript_enabled = true
  @screenshot_task_queue = ScreenshotTaskQueue.new

  @workers = {}
  @client.on_event('Target.attachedToTarget') do |event|
    if event['targetInfo']['type'] != 'worker'
      # If we don't detach from service workers, they will never die.
      await @client.send_message('Target.detachFromTarget', sessionId: event['sessionId'])
      next
    end

    session = Puppeteer::Connection.from_session(@client).session(event['sessionId']) # rubocop:disable Lint/UselessAssignment
    #   const worker = new Worker(session, event.targetInfo.url, this._addConsoleMessage.bind(this), this._handleException.bind(this));
    #   this._workers.set(event.sessionId, worker);
    #   this.emit(PageEmittedEvents::WorkerCreated, worker);
  end
  @client.on_event('Target.detachedFromTarget') do |event|
    session_id = event['sessionId']
    worker = @workers[session_id]
    next unless worker

    emit_event(PageEmittedEvents::WorkerDestroyed, worker)
    @workers.delete(session_id)
  end

  @frame_manager.on_event(FrameManagerEmittedEvents::FrameAttached) do |event|
    emit_event(PageEmittedEvents::FrameAttached, event)
  end
  @frame_manager.on_event(FrameManagerEmittedEvents::FrameDetached) do |event|
    emit_event(PageEmittedEvents::FrameDetached, event)
  end
  @frame_manager.on_event(FrameManagerEmittedEvents::FrameNavigated) do |event|
    emit_event(PageEmittedEvents::FrameNavigated, event)
  end

  network_manager = @frame_manager.network_manager
  network_manager.on_event(NetworkManagerEmittedEvents::Request) do |event|
    emit_event(PageEmittedEvents::Request, event)
  end
  network_manager.on_event(NetworkManagerEmittedEvents::Response) do |event|
    emit_event(PageEmittedEvents::Response, event)
  end
  network_manager.on_event(NetworkManagerEmittedEvents::RequestFailed) do |event|
    emit_event(PageEmittedEvents::RequestFailed, event)
  end
  network_manager.on_event(NetworkManagerEmittedEvents::RequestFinished) do |event|
    emit_event(PageEmittedEvents::RequestFinished, event)
  end
  @file_chooser_interception_is_disabled = false
  @file_chooser_interceptors = Set.new

  @client.on_event('Page.domContentEventFired') do |event|
    emit_event(PageEmittedEvents::DOMContentLoaded)
  end
  @client.on_event('Page.loadEventFired') do |event|
    emit_event(PageEmittedEvents::Load)
  end
  @client.on('Runtime.consoleAPICalled') do |event|
    handle_console_api(event)
  end
  # client.on('Runtime.bindingCalled', event => this._onBindingCalled(event));
  @client.on_event('Page.javascriptDialogOpening') do |event|
    handle_dialog_opening(event)
  end
  @client.on_event('Runtime.exceptionThrown') do |exception|
    handle_exception(exception['exceptionDetails'])
  end
  @client.on_event('Inspector.targetCrashed') do |event|
    handle_target_crashed
  end
  # client.on('Performance.metrics', event => this._emitMetrics(event));
  @client.on_event('Log.entryAdded') do |event|
    handle_log_entry_added(event)
  end
  @client.on_event('Page.fileChooserOpened') do |event|
    handle_file_chooser(event)
  end
  @target.is_closed_promise.then do
    emit_event(PageEmittedEvents::Close)
    @closed = true
  end
end

Instance Attribute Details

#accessibility ⇒ Object (readonly)

Returns the value of attribute accessibility.



248
249
250
 
# File 'lib/puppeteer/page.rb', line 248

def accessibility
  @accessibility
end

#coverage ⇒ Object (readonly)

Returns the value of attribute coverage.



248
249
250
 
# File 'lib/puppeteer/page.rb', line 248

def coverage
  @coverage
end

#javascript_enabled ⇒ Object Also known as: javascript_enabled?

Returns the value of attribute javascript_enabled.



204
205
206
 
# File 'lib/puppeteer/page.rb', line 204

def javascript_enabled
  @javascript_enabled
end

#mouse ⇒ Object (readonly)

Returns the value of attribute mouse.



1036
1037
1038
 
# File 'lib/puppeteer/page.rb', line 1036

def mouse
  @mouse
end

#target ⇒ Object (readonly)

Returns the value of attribute target.



204
205
206
 
# File 'lib/puppeteer/page.rb', line 204

def target
  @target
end

#touch_screen ⇒ Object (readonly)

Returns the value of attribute touch_screen.



248
249
250
 
# File 'lib/puppeteer/page.rb', line 248

def touch_screen
  @touch_screen
end

#tracing ⇒ Object (readonly)

Returns the value of attribute tracing.



248
249
250
 
# File 'lib/puppeteer/page.rb', line 248

def tracing
  @tracing
end

#viewport ⇒ Object

Returns the value of attribute viewport.



846
847
848
 
# File 'lib/puppeteer/page.rb', line 846

def viewport
  @viewport
end

Class Method Details

.create(client, target, ignore_https_errors, default_viewport) ⇒ !Promise<!Page> 



19
20
21
22
23
24
25
26
 
# File 'lib/puppeteer/page.rb', line 19

def self.create(client, target, ignore_https_errors, default_viewport)
  page = Puppeteer::Page.new(client, target, ignore_https_errors)
  page.init
  if default_viewport
    page.viewport = default_viewport
  end
  page
end

Instance Method Details

#add_script_tag(url: nil, path: nil, content: nil, type: nil) ⇒ Object 



384
385
386
 
# File 'lib/puppeteer/page.rb', line 384

def add_script_tag(url: nil, path: nil, content: nil, type: nil)
  main_frame.add_script_tag(url: url, path: path, content: content, type: type)
end

#add_style_tag(url: nil, path: nil, content: nil) ⇒ Object 



391
392
393
 
# File 'lib/puppeteer/page.rb', line 391

def add_style_tag(url: nil, path: nil, content: nil)
  main_frame.add_style_tag(url: url, path: path, content: content)
end

#async_wait_for_navigation(timeout: nil, wait_until: nil) ⇒ Object 



648
 
# File 'lib/puppeteer/page.rb', line 648

define_async_method :async_wait_for_navigation

#async_wait_for_request(url: nil, predicate: nil, timeout: nil) ⇒ Object

Waits until request URL matches or request matches the given predicate.

Waits until request URL matches

wait_for_request(url: 'https://example.com/awesome')

Waits until request matches the given predicate

wait_for_request(predicate: -> (req){ req.url.start_with?('https://example.com/search') })



718
 
# File 'lib/puppeteer/page.rb', line 718

define_async_method :async_wait_for_request

#async_wait_for_response(url: nil, predicate: nil, timeout: nil) ⇒ Object 



744
 
# File 'lib/puppeteer/page.rb', line 744

define_async_method :async_wait_for_response

#authenticate(username: nil, password: nil) ⇒ Object 



429
430
431
 
# File 'lib/puppeteer/page.rb', line 429

def authenticate(username: nil, password: nil)
  @frame_manager.network_manager.authenticate(username: username, password: password)
end

#browser ⇒ Object 



207
208
209
 
# File 'lib/puppeteer/page.rb', line 207

def browser
  @target.browser
end

#browser_context ⇒ Object 



211
212
213
 
# File 'lib/puppeteer/page.rb', line 211

def browser_context
  @target.browser_context
end

#bypass_csp=(enabled) ⇒ Object 



784
785
786
 
# File 'lib/puppeteer/page.rb', line 784

def bypass_csp=(enabled)
  @client.send_message('Page.setBypassCSP', enabled: enabled)
end

#cache_enabled=(enabled) ⇒ Object 



894
895
896
 
# File 'lib/puppeteer/page.rb', line 894

def cache_enabled=(enabled)
  @frame_manager.network_manager.cache_enabled = enabled
end

#click(selector, delay: nil, button: nil, click_count: nil) ⇒ Object 



1042
1043
1044
 
# File 'lib/puppeteer/page.rb', line 1042

def click(selector, delay: nil, button: nil, click_count: nil)
  main_frame.click(selector, delay: delay, button: button, click_count: click_count)
end

#close(run_before_unload: false) ⇒ Object 



1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
 
# File 'lib/puppeteer/page.rb', line 1012

def close(run_before_unload: false)
  unless @client.connection
    raise 'Protocol error: Connection closed. Most likely the page has been closed.'
  end

  if run_before_unload
    @client.send_message('Page.close')
  else
    @client.connection.send_message('Target.closeTarget', targetId: @target.target_id)
    await @target.is_closed_promise

    # @closed sometimes remains false, so wait for @closed = true with 100ms timeout.
    25.times do
      break if @closed
      sleep 0.004
    end
  end
end

#closed? ⇒ boolean 



1032
1033
1034
 
# File 'lib/puppeteer/page.rb', line 1032

def closed?
  @closed
end

#content ⇒ String 



606
607
608
 
# File 'lib/puppeteer/page.rb', line 606

def content
  main_frame.content
end

#content=(html) ⇒ Object 



618
619
620
 
# File 'lib/puppeteer/page.rb', line 618

def content=(html)
  main_frame.set_content(html)
end

#cookies(*urls) ⇒ Array<Hash> 



352
353
354
 
# File 'lib/puppeteer/page.rb', line 352

def cookies(*urls)
  @client.send_message('Network.getCookies', urls: (urls.empty? ? [url] : urls))['cookies']
end

#default_navigation_timeout=(timeout) ⇒ Object 



274
275
276
 
# File 'lib/puppeteer/page.rb', line 274

def default_navigation_timeout=(timeout)
  @timeout_settings.default_navigation_timeout = timeout
end

#default_timeout=(timeout) ⇒ Object 



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

def default_timeout=(timeout)
  @timeout_settings.default_timeout = timeout
end

#delete_cookie(*cookies) ⇒ Object 



356
357
358
359
360
361
362
363
 
# File 'lib/puppeteer/page.rb', line 356

def delete_cookie(*cookies)
  page_url = url
  starts_with_http = page_url.start_with?("http")
  cookies.each do |cookie|
    item = (starts_with_http ? { url: page_url } : {}).merge(cookie)
    @client.send_message("Network.deleteCookies", item)
  end
end

#emulate(device) ⇒ Object 



771
772
773
774
 
# File 'lib/puppeteer/page.rb', line 771

def emulate(device)
  self.viewport = device.viewport
  self.user_agent = device.user_agent
end

#emulate_idle_state(is_user_active: nil, is_screen_unlocked: nil) ⇒ Object 



826
827
828
829
830
831
832
833
834
835
836
837
 
# File 'lib/puppeteer/page.rb', line 826

def emulate_idle_state(is_user_active: nil, is_screen_unlocked: nil)
  overrides = {
    isUserActive: is_user_active,
    isScreenUnlocked: is_screen_unlocked,
  }.compact

  if overrides.empty?
    @client.send_message('Emulation.clearIdleOverride')
  else
    @client.send_message('Emulation.setIdleOverride', overrides)
  end
end

#emulate_media_type(media_type) ⇒ Object 



789
790
791
792
793
794
795
 
# File 'lib/puppeteer/page.rb', line 789

def emulate_media_type(media_type)
  media_type_str = media_type.to_s
  unless ['screen', 'print', ''].include?(media_type_str)
    raise ArgumentError.new("Unsupported media type: #{media_type}")
  end
  @client.send_message('Emulation.setEmulatedMedia', media: media_type_str)
end

#emulate_timezone(timezone_id) ⇒ Object 



814
815
816
817
818
819
820
821
822
 
# File 'lib/puppeteer/page.rb', line 814

def emulate_timezone(timezone_id)
  @client.send_message('Emulation.setTimezoneOverride', timezoneId: timezone_id || '')
rescue => err
  if err.message.include?('Invalid timezone')
    raise ArgumentError.new("Invalid timezone ID: #{timezone_id}")
  else
    raise err
  end
end

#eval_on_selector(selector, page_function, *args) ⇒ Object Also known as: Seval

‘$eval()` in JavaScript.



324
325
326
 
# File 'lib/puppeteer/page.rb', line 324

def eval_on_selector(selector, page_function, *args)
  main_frame.eval_on_selector(selector, page_function, *args)
end

#eval_on_selector_all(selector, page_function, *args) ⇒ Object Also known as: SSeval

‘$$eval()` in JavaScript.



335
336
337
 
# File 'lib/puppeteer/page.rb', line 335

def eval_on_selector_all(selector, page_function, *args)
  main_frame.eval_on_selector_all(selector, page_function, *args)
end

#evaluate(page_function, *args) ⇒ !Promise<*> 



851
852
853
 
# File 'lib/puppeteer/page.rb', line 851

def evaluate(page_function, *args)
  main_frame.evaluate(page_function, *args)
end

#evaluate_handle(page_function, *args) ⇒ !Promise<!Puppeteer.JSHandle> 



306
307
308
309
 
# File 'lib/puppeteer/page.rb', line 306

def evaluate_handle(page_function, *args)
  context = main_frame.execution_context
  context.evaluate_handle(page_function, *args)
end

#evaluate_on_new_document(page_function, *args) ⇒ Object 



882
883
884
885
886
887
888
889
890
891
 
# File 'lib/puppeteer/page.rb', line 882

def evaluate_on_new_document(page_function, *args)
  source =
    if ['=>', 'async', 'function'].any? { |keyword| page_function.include?(keyword) }
      JavaScriptFunction.new(page_function, args).source
    else
      JavaScriptExpression.new(page_function).source
    end

  @client.send_message('Page.addScriptToEvaluateOnNewDocument', source: source)
end

#extra_http_headers=(headers) ⇒ Object 



434
435
436
 
# File 'lib/puppeteer/page.rb', line 434

def extra_http_headers=(headers)
  @frame_manager.network_manager.extra_http_headers = headers
end

#focus(selector) ⇒ Object 



1049
1050
1051
 
# File 'lib/puppeteer/page.rb', line 1049

def focus(selector)
  main_frame.focus(selector)
end

#frames ⇒ Object 



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

def frames
  @frame_manager.frames
end

#geolocation=(geolocation) ⇒ Object 



200
201
202
 
# File 'lib/puppeteer/page.rb', line 200

def geolocation=(geolocation)
  @client.send_message('Emulation.setGeolocationOverride', geolocation.to_h)
end

#go_back(timeout: nil, wait_until: nil) ⇒ Object 



748
749
750
 
# File 'lib/puppeteer/page.rb', line 748

def go_back(timeout: nil, wait_until: nil)
  go(-1, timeout: timeout, wait_until: wait_until)
end

#go_forward(timeout: nil, wait_until: nil) ⇒ Object 



754
755
756
 
# File 'lib/puppeteer/page.rb', line 754

def go_forward(timeout: nil, wait_until: nil)
  go(+1, timeout: timeout, wait_until: wait_until)
end

#goto(url, referer: nil, timeout: nil, wait_until: nil) ⇒ Object 



626
627
628
 
# File 'lib/puppeteer/page.rb', line 626

def goto(url, referer: nil, timeout: nil, wait_until: nil)
  main_frame.goto(url, referer: referer, timeout: timeout, wait_until: wait_until)
end

#handle_file_chooser(event) ⇒ Object 



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

def handle_file_chooser(event)
  return if @file_chooser_interceptors.empty?

  frame = @frame_manager.frame(event['frameId'])
  context = frame.execution_context
  element = context.adopt_backend_node_id(event['backendNodeId'])
  interceptors = @file_chooser_interceptors.to_a
  @file_chooser_interceptors.clear
  file_chooser = Puppeteer::FileChooser.new(element, event)
  interceptors.each do |promise|
    promise.fulfill(file_chooser)
  end
end

#hover(selector) ⇒ Object 



1056
1057
1058
 
# File 'lib/puppeteer/page.rb', line 1056

def hover(selector)
  main_frame.hover(selector)
end

#init ⇒ Object 



128
129
130
131
132
133
134
135
 
# File 'lib/puppeteer/page.rb', line 128

def init
  await_all(
    @frame_manager.async_init,
    @client.async_send_message('Target.setAutoAttach', autoAttach: true, waitForDebuggerOnStart: false, flatten: true),
    @client.async_send_message('Performance.enable'),
    @client.async_send_message('Log.enable'),
  )
end

#keyboard(&block) ⇒ Object 



250
251
252
253
254
 
# File 'lib/puppeteer/page.rb', line 250

def keyboard(&block)
  @keyboard.instance_eval(&block) unless block.nil?

  @keyboard
end

#main_frame ⇒ Object 



244
245
246
 
# File 'lib/puppeteer/page.rb', line 244

def main_frame
  @frame_manager.main_frame
end

#offline_mode=(enabled) ⇒ Object 



269
270
271
 
# File 'lib/puppeteer/page.rb', line 269

def offline_mode=(enabled)
  @frame_manager.network_manager.offline_mode = enabled
end

#on(event_name, &block) ⇒ Object 



138
139
140
141
142
143
144
 
# File 'lib/puppeteer/page.rb', line 138

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

  super(event_name.to_s, &block)
end

#once(event_name, &block) ⇒ Object 



147
148
149
150
151
152
153
 
# File 'lib/puppeteer/page.rb', line 147

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

  super(event_name.to_s, &block)
end

#pdf(options = {}) ⇒ String 



996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
 
# File 'lib/puppeteer/page.rb', line 996

def pdf(options = {})
  pdf_options = PDFOptions.new(options)
  omit_background = options[:omit_background]
  set_transparent_background_color if omit_background
  result = @client.send_message('Page.printToPDF', pdf_options.page_print_args)
  reset_default_background_color if omit_background
  Puppeteer::ProtocolStreamReader.new(client: @client, handle: result['stream'], path: pdf_options.path).read
rescue => err
  if err.message.include?('PrintToPDF is not implemented')
    raise PrintToPdfIsNotImplementedError.new
  else
    raise
  end
end

#query_objects(prototype_handle) ⇒ !Promise<!Puppeteer.JSHandle> 



315
316
317
318
 
# File 'lib/puppeteer/page.rb', line 315

def query_objects(prototype_handle)
  context = main_frame.execution_context
  context.query_objects(prototype_handle)
end

#query_selector(selector) ⇒ !Promise<?Puppeteer.ElementHandle> Also known as: S

‘$()` in JavaScript.



286
287
288
 
# File 'lib/puppeteer/page.rb', line 286

def query_selector(selector)
  main_frame.query_selector(selector)
end

#query_selector_all(selector) ⇒ !Promise<!Array<!Puppeteer.ElementHandle>> Also known as: SS

‘$$()` in JavaScript.



296
297
298
 
# File 'lib/puppeteer/page.rb', line 296

def query_selector_all(selector)
  main_frame.query_selector_all(selector)
end

#reload(timeout: nil, wait_until: nil) ⇒ Puppeteer::Response 



633
634
635
636
637
638
 
# File 'lib/puppeteer/page.rb', line 633

def reload(timeout: nil, wait_until: nil)
  await_all(
    async_wait_for_navigation(timeout: timeout, wait_until: wait_until),
    @client.async_send_message('Page.reload'),
  ).first
end

#request_interception=(value) ⇒ Object 



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

def request_interception=(value)
  @frame_manager.network_manager.request_interception = value
end

#screenshot(type: nil, path: nil, full_page: nil, clip: nil, quality: nil, omit_background: nil, encoding: nil) ⇒ Object 



910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
 
# File 'lib/puppeteer/page.rb', line 910

def screenshot(type: nil, path: nil, full_page: nil, clip: nil, quality: nil, omit_background: nil, encoding: nil)
  options = {
    type: type,
    path: path,
    full_page: full_page,
    clip: clip,
    quality:  quality,
    omit_background: omit_background,
    encoding: encoding,
  }.compact
  screenshot_options = ScreenshotOptions.new(options)

  @screenshot_task_queue.post_task do
    screenshot_task(screenshot_options.type, screenshot_options)
  end
end

#select(selector, *values) ⇒ !Promise<!Array<string>> 



1063
1064
1065
 
# File 'lib/puppeteer/page.rb', line 1063

def select(selector, *values)
  main_frame.select(selector, *values)
end

#set_content(html, timeout: nil, wait_until: nil) ⇒ Object 



613
614
615
 
# File 'lib/puppeteer/page.rb', line 613

def set_content(html, timeout: nil, wait_until: nil)
  main_frame.set_content(html, timeout: timeout, wait_until: wait_until)
end

#set_cookie(*cookies) ⇒ Object 



365
366
367
368
369
370
371
372
373
374
375
376
377
378
 
# File 'lib/puppeteer/page.rb', line 365

def set_cookie(*cookies)
  page_url = url
  starts_with_http = page_url.start_with?("http")
  items = cookies.map do |cookie|
    (starts_with_http ? { url: page_url } : {}).merge(cookie).tap do |item|
      raise ArgumentError.new("Blank page can not have cookie \"#{item[:name]}\"") if item[:url] == "about:blank"
      raise ArgumetnError.new("Data URL page can not have cookie \"#{item[:name]}\"") if item[:url]&.start_with?("data:")
    end
  end
  delete_cookie(*items)
  unless items.empty?
    @client.send_message("Network.setCookies", cookies: items)
  end
end

#Sx(expression) ⇒ !Promise<!Array<!Puppeteer.ElementHandle>>

‘$x()` in JavaScript. $ is not allowed to use as a method name in Ruby.



345
346
347
 
# File 'lib/puppeteer/page.rb', line 345

def Sx(expression)
  main_frame.Sx(expression)
end

#tap(selector: nil, &block) ⇒ Object 



1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
 
# File 'lib/puppeteer/page.rb', line 1070

def tap(selector: nil, &block)
  # resolves double meaning of tap.
  if selector.nil? && block
    # Original usage of Object#tap.
    #
    # browser.new_page.tap do |page|
    #   ...
    # end
    super(&block)
  else
    # Puppeteer's Page#tap.
    main_frame.tap(selector)
  end
end

#title ⇒ String 



899
900
901
 
# File 'lib/puppeteer/page.rb', line 899

def title
  main_frame.title
end

#type_text(selector, text, delay: nil) ⇒ Object 



1090
1091
1092
 
# File 'lib/puppeteer/page.rb', line 1090

def type_text(selector, text, delay: nil)
  main_frame.type_text(selector, text, delay: delay)
end

#url ⇒ String 



601
602
603
 
# File 'lib/puppeteer/page.rb', line 601

def url
  main_frame.url
end

#user_agent=(user_agent) ⇒ Object 



439
440
441
 
# File 'lib/puppeteer/page.rb', line 439

def user_agent=(user_agent)
  @frame_manager.network_manager.user_agent = user_agent
end

#wait_for_file_chooser(timeout: nil) ⇒ Puppeteer::FileChooser 



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/puppeteer/page.rb', line 177

def wait_for_file_chooser(timeout: nil)
  if @file_chooser_interceptors.empty?
    @client.send_message('Page.setInterceptFileChooserDialog', enabled: true)
  end

  option_timeout = timeout || @timeout_settings.timeout
  promise = resolvable_future
  @file_chooser_interceptors << promise

  begin
    Timeout.timeout(option_timeout / 1000.0) do
      promise.value!
    end
  rescue Timeout::Error
    raise FileChooserTimeoutError.new(timeout: option_timeout)
  ensure
    @file_chooser_interceptors.delete(promise)
  end
end

#wait_for_function(page_function, args: [], polling: nil, timeout: nil) ⇒ Puppeteer::JSHandle 



1126
1127
1128
 
# File 'lib/puppeteer/page.rb', line 1126

def wait_for_function(page_function, args: [], polling: nil, timeout: nil)
  main_frame.wait_for_function(page_function, args: args, polling: polling, timeout: timeout)
end

#wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil) ⇒ Object 



1100
1101
1102
 
# File 'lib/puppeteer/page.rb', line 1100

def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
  main_frame.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
end

#wait_for_timeout(milliseconds) ⇒ Object 



1107
1108
1109
 
# File 'lib/puppeteer/page.rb', line 1107

def wait_for_timeout(milliseconds)
  main_frame.wait_for_timeout(milliseconds)
end

#wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil) ⇒ Object 



1115
1116
1117
 
# File 'lib/puppeteer/page.rb', line 1115

def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
  main_frame.wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
end

#workers ⇒ Object 



260
261
262
 
# File 'lib/puppeteer/page.rb', line 260

def workers
  @workers.values
end