Class: Puppeteer::ElementHandle

Inherits:
JSHandle
  • Object
show all
Includes:
IfPresent
Defined in:
lib/puppeteer/element_handle.rb,
lib/puppeteer/element_handle/point.rb,
lib/puppeteer/element_handle/box_model.rb,
lib/puppeteer/element_handle/bounding_box.rb

Defined Under Namespace

Classes: BoundingBox, BoxModel, ElementNotFoundError, ElementNotVisibleError, Point, ScrollIntoViewError

Instance Attribute Summary

Attributes inherited from JSHandle

#context, #remote_object

Instance Method Summary collapse

Methods included from IfPresent

#if_present

Methods inherited from JSHandle

#async_evaluate, #async_evaluate_handle, create, #dispose, #disposed?, #evaluate, #evaluate_handle, #execution_context, #json_value, #properties

Constructor Details

#initialize(context:, client:, remote_object:, page:, frame_manager:) ⇒ ElementHandle

Returns a new instance of ElementHandle.

Parameters:



14
15
16
17
18
19
 
# File 'lib/puppeteer/element_handle.rb', line 14

def initialize(context:, client:, remote_object:, page:, frame_manager:)
  super(context: context, client: client, remote_object: remote_object)
  @page = page
  @frame_manager = frame_manager
  @disposed = false
end

Instance Method Details

#as_element ⇒ Object 



21
22
23
 
# File 'lib/puppeteer/element_handle.rb', line 21

def as_element
  self
end

#async_press ⇒ Future

Parameters:

  • key (String)
  • delay (number|nil)

Returns:

  • (Future) 


234
235
236
 
# File 'lib/puppeteer/element_handle.rb', line 234

async def async_press(key, delay: nil)
  press(key, delay: delay)
end

#async_Seval ⇒ Object

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

Parameters:

  • selector (String)
  • page_function (String)

Returns:

  • (Object) 


363
364
365
 
# File 'lib/puppeteer/element_handle.rb', line 363

async def async_Seval(selector, page_function, *args)
  Seval(selector, page_function, *args)
end

#async_SSeval ⇒ Object

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

Parameters:

  • selector (String)
  • page_function (String)

Returns:

  • (Object) 


386
387
388
 
# File 'lib/puppeteer/element_handle.rb', line 386

async def async_SSeval(selector, page_function, *args)
  SSeval(selector, page_function, *args)
end

#async_type_text ⇒ Future

Parameters:

  • text (String)
  • delay (number|nil)

Returns:

  • (Future) 


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

async def async_type_text(text, delay: nil)
  type_text(text, delay: delay)
end

#bounding_box ⇒ BoundingBox|nil

Returns:



239
240
241
242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/puppeteer/element_handle.rb', line 239

def bounding_box
  if_present(box_model) do |result_model|
    quads = result_model.border

    x = quads.map(&:x).min
    y = quads.map(&:y).min
    BoundingBox.new(
      x: x,
      y: y,
      width: quads.map(&:x).max - x,
      height: quads.map(&:y).max - y,
    )
  end
end

#box_model ⇒ BoxModel|nil

Returns:



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

def box_model
  if_present(@remote_object.box_model(@client)) do |result|
    BoxModel.new(result['model'])
  end
end

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

Parameters:

  • delay (Number) (defaults to: nil)
  • button (String) (defaults to: nil) —

    “left”|“right”|“middle”

  • click_count (Number) (defaults to: nil) 


117
118
119
120
121
 
# File 'lib/puppeteer/element_handle.rb', line 117

def click(delay: nil, button: nil, click_count: nil)
  scroll_into_view_if_needed
  point = clickable_point
  @page.mouse.click(point.x, point.y, delay: delay, button: button, click_count: click_count)
end

#clickable_point ⇒ Object 



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/element_handle.rb', line 64

def clickable_point
  result = @remote_object.content_quads(@client)
  if !result || result["quads"].empty?
    raise ElementNotVisibleError.new
  end

  # Filter out quads that have too small area to click into.
  layout_metrics = @client.send_message('Page.getLayoutMetrics')
  client_width = layout_metrics["layoutViewport"]["clientWidth"]
  client_height = layout_metrics["layoutViewport"]["clientHeight"]

  quads = result["quads"].
            map { |quad| from_protocol_quad(quad) }.
            map { |quad| intersect_quad_with_viewport(quad, client_width, client_height) }.
            select { |quad| compute_quad_area(quad) > 1 }
  if quads.empty?
    raise ElementNotVisibleError.new
  end

  # Return the middle point of the first quad.
  quads.first.reduce(:+) / 4
end

#content_frame ⇒ Object 



25
26
27
28
29
30
31
32
33
 
# File 'lib/puppeteer/element_handle.rb', line 25

def content_frame
  node_info = @remote_object.node_info
  frame_id = node_info['node']['frameId']
  if frame_id.is_a?(String)
    @frame_manager.frame(frame_id)
  else
    nil
  end
end

#focus ⇒ Object 



202
203
204
 
# File 'lib/puppeteer/element_handle.rb', line 202

def focus
  evaluate('element => element.focus()')
end

#press(key, delay: nil) ⇒ Object

Parameters:

  • key (String)
  • delay (number|nil) (defaults to: nil) 


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

def press(key, delay: nil)
  focus
  @page.keyboard.press(key, delay: delay)
end

#S(selector) ⇒ Object

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

Parameters:

  • selector (String) 


312
313
314
315
316
317
318
319
320
321
322
323
324
 
# File 'lib/puppeteer/element_handle.rb', line 312

def S(selector)
  handle = evaluate_handle(
    '(element, selector) => element.querySelector(selector)',
    selector,
  )
  element = handle.as_element

  if element
    return element
  end
  handle.dispose
  nil
end

#screenshot(options = {}) ⇒ Object 



261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/puppeteer/element_handle.rb', line 261

def screenshot(options = {})
  needs_viewport_reset = false

  box = bounding_box
  unless box
    raise ElementNotVisibleError.new
  end

  viewport = @page.viewport
  if viewport && (box.width > viewport.width || box.height > viewport.height)
    new_viewport = viewport.merge(
      width: [viewport.width, box.width.to_i].min,
      height: [viewport.height, box.height.to_i].min,
    )
    @page.viewport = new_viewport

    needs_viewport_reset = true
  end
  scroll_into_view_if_needed

  box = bounding_box
  unless box
    raise ElementNotVisibleError.new
  end
  if box.width == 0
    raise 'Node has 0 width.'
  end
  if box.height == 0
    raise 'Node has 0 height.'
  end

  layout_metrics = @client.send_message('Page.getLayoutMetrics')
  page_x = layout_metrics["layoutViewport"]["pageX"]
  page_y = layout_metrics["layoutViewport"]["pageY"]

  clip = {
    x: page_x + box.x,
    y: page_y + box.y,
    width: box.width,
    height: box.height,
  }

  @page.screenshot({ clip: clip }.merge(options))
ensure
  if needs_viewport_reset
    @page.viewport = viewport
  end
end

#scroll_into_view_if_needed ⇒ Object 



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

def scroll_into_view_if_needed
  js = <<~JAVASCRIPT
    async(element, pageJavascriptEnabled) => {
      if (!element.isConnected)
        return 'Node is detached from document';
      if (element.nodeType !== Node.ELEMENT_NODE)
        return 'Node is not of type HTMLElement';

      element.scrollIntoViewIfNeeded({block: 'center', inline: 'center', behavior: 'instant'});
      return false;
    }
  JAVASCRIPT
  error = evaluate(js, @page.javascript_enabled) # returns String or false
  if error
    raise ScrollIntoViewError.new(error)
  end
  # clickpoint is often calculated before scrolling is completed.
  # So, just sleep about 10 frames
  sleep 0.16
end

#select(*values) ⇒ Array<String>

Returns:

  • (Array<String>) 


131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/puppeteer/element_handle.rb', line 131

def select(*values)
  if nonstring = values.find { |value| !value.is_a?(String) }
    raise ArgumentError.new("Values must be strings. Found value \"#{nonstring}\" of type \"#{nonstring.class}\"")
  end

  fn = <<~JAVASCRIPT
  (element, values) => {
    if (element.nodeName.toLowerCase() !== 'select') {
      throw new Error('Element is not a <select> element.');
    }

    const options = Array.from(element.options);
    element.value = undefined;
    for (const option of options) {
      option.selected = values.includes(option.value);
      if (option.selected && !element.multiple) {
        break;
      }
    }
    element.dispatchEvent(new Event('input', { bubbles: true }));
    element.dispatchEvent(new Event('change', { bubbles: true }));
    return options.filter(option => option.selected).map(option => option.value);
  }
  JAVASCRIPT
  evaluate(fn, values)
end

#Seval(selector, page_function, *args) ⇒ Object

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

Parameters:

  • selector (String)
  • page_function (String)

Returns:

  • (Object) 


348
349
350
351
352
353
354
355
356
357
 
# File 'lib/puppeteer/element_handle.rb', line 348

def Seval(selector, page_function, *args)
  element_handle = S(selector)
  unless element_handle
    raise ElementNotFoundError.new(selector)
  end
  result = element_handle.evaluate(page_function, *args)
  element_handle.dispose

  result
end

#SS(selector) ⇒ Object

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

Parameters:

  • selector (String) 


328
329
330
331
332
333
334
335
336
 
# File 'lib/puppeteer/element_handle.rb', line 328

def SS(selector)
  handles = evaluate_handle(
    '(element, selector) => element.querySelectorAll(selector)',
    selector,
  )
  properties = handles.properties
  handles.dispose
  properties.values.map(&:as_element).compact
end

#SSeval(selector, page_function, *args) ⇒ Object

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

Parameters:

  • selector (String)
  • page_function (String)

Returns:

  • (Object) 


371
372
373
374
375
376
377
378
379
380
 
# File 'lib/puppeteer/element_handle.rb', line 371

def SSeval(selector, page_function, *args)
  handles = evaluate_handle(
    '(element, selector) => Array.from(element.querySelectorAll(selector))',
    selector,
  )
  result = handles.evaluate(page_function, *args)
  handles.dispose

  result
end

#Sx(expression) ⇒ Array<ElementHandle>

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

Parameters:

  • expression (String)

Returns:



393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
 
# File 'lib/puppeteer/element_handle.rb', line 393

def Sx(expression)
  fn = <<~JAVASCRIPT
  (element, expression) => {
    const document = element.ownerDocument || element;
    const iterator = document.evaluate(expression, element, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE);
    const array = [];
    let item;
    while ((item = iterator.iterateNext()))
      array.push(item);
    return array;
  }
  JAVASCRIPT
  handles = evaluate_handle(fn, expression)
  properties = handles.properties
  handles.dispose
  properties.values.map(&:as_element).compact
end

#tap(&block) ⇒ Object 



190
191
192
193
194
195
196
 
# File 'lib/puppeteer/element_handle.rb', line 190

def tap(&block)
  return super(&block) if block

  scroll_into_view_if_needed
  point = clickable_point
  @page.touchscreen.tap(point.x, point.y)
end

#type_text(text, delay: nil) ⇒ Object

Parameters:

  • text (String)
  • delay (number|nil) (defaults to: nil) 


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

def type_text(text, delay: nil)
  focus
  @page.keyboard.type_text(text, delay: delay)
end

#upload_file(*file_paths) ⇒ Object

Parameters:

  • file_paths (Array<String>) 


159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/puppeteer/element_handle.rb', line 159

def upload_file(*file_paths)
  is_multiple = evaluate("el => el.multiple")
  if !is_multiple && file_paths.length >= 2
    raise ArgumentError.new('Multiple file uploads only work with <input type=file multiple>')
  end

  if error_path = file_paths.find { |file_path| !File.exist?(file_path) }
    raise ArgmentError.new("#{error_path} does not exist or is not readable")
  end

  backend_node_id = @remote_object.node_info(@client)["node"]["backendNodeId"]

  # The zero-length array is a special case, it seems that DOM.setFileInputFiles does
  # not actually update the files in that case, so the solution is to eval the element
  # value to a new FileList directly.
  if file_paths.empty?
    fn = <<~JAVASCRIPT
    (element) => {
      element.files = new DataTransfer().files;

      // Dispatch events for this case because it should behave akin to a user action.
      element.dispatchEvent(new Event('input', { bubbles: true }));
      element.dispatchEvent(new Event('change', { bubbles: true }));
    }
    JAVASCRIPT
    await this.evaluate(fn)
  else
    @remote_object.set_file_input_files(@client, file_paths, backend_node_id)
  end
end