puppeteer-ruby 0.35.1 → 0.37.2

data/lib/puppeteer/devices.rb

@@ -1,3 +1,5 @@
+require_relative './device'
+
 Puppeteer::DEVICES = Hash[
   [
     {
@@ -156,6 +158,84 @@ Puppeteer::DEVICES = Hash[
         isLandscape: true,
       },
     },
+    {
+      name: 'Galaxy S8',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 7.0; SM-G950U Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.84 Mobile Safari/537.36',
+      viewport: {
+        width: 360,
+        height: 740,
+        deviceScaleFactor: 3,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: false,
+      },
+    },
+    {
+      name: 'Galaxy S8 landscape',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 7.0; SM-G950U Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.84 Mobile Safari/537.36',
+      viewport: {
+        width: 740,
+        height: 360,
+        deviceScaleFactor: 3,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: true,
+      },
+    },
+    {
+      name: 'Galaxy S9+',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 8.0.0; SM-G965U Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.111 Mobile Safari/537.36',
+      viewport: {
+        width: 320,
+        height: 658,
+        deviceScaleFactor: 4.5,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: false,
+      },
+    },
+    {
+      name: 'Galaxy S9+ landscape',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 8.0.0; SM-G965U Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.111 Mobile Safari/537.36',
+      viewport: {
+        width: 658,
+        height: 320,
+        deviceScaleFactor: 4.5,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: true,
+      },
+    },
+    {
+      name: 'Galaxy Tab S4',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 8.1.0; SM-T837A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.80 Safari/537.36',
+      viewport: {
+        width: 712,
+        height: 1138,
+        deviceScaleFactor: 2.25,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: false,
+      },
+    },
+    {
+      name: 'Galaxy Tab S4 landscape',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 8.1.0; SM-T837A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.80 Safari/537.36',
+      viewport: {
+        width: 1138,
+        height: 712,
+        deviceScaleFactor: 2.25,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: true,
+      },
+    },
     {
       name: 'iPad',
       userAgent:
@@ -1001,6 +1081,58 @@ Puppeteer::DEVICES = Hash[
         isLandscape: true,
       },
     },
+    {
+      name: 'Pixel 3',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 9; Pixel 3 Build/PQ1A.181105.017.A1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.158 Mobile Safari/537.36',
+      viewport: {
+        width: 393,
+        height: 786,
+        deviceScaleFactor: 2.75,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: false,
+      },
+    },
+    {
+      name: 'Pixel 3 landscape',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 9; Pixel 3 Build/PQ1A.181105.017.A1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.158 Mobile Safari/537.36',
+      viewport: {
+        width: 786,
+        height: 393,
+        deviceScaleFactor: 2.75,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: true,
+      },
+    },
+    {
+      name: 'Pixel 4',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 10; Pixel 4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Mobile Safari/537.36',
+      viewport: {
+        width: 353,
+        height: 745,
+        deviceScaleFactor: 3,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: false,
+      },
+    },
+    {
+      name: 'Pixel 4 landscape',
+      userAgent:
+        'Mozilla/5.0 (Linux; Android 10; Pixel 4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Mobile Safari/537.36',
+      viewport: {
+        width: 745,
+        height: 353,
+        deviceScaleFactor: 3,
+        isMobile: true,
+        hasTouch: true,
+        isLandscape: true,
+      },
+    },
   ].map do |json|
     [
       json[:name],

data/lib/puppeteer/dom_world.rb

@@ -233,12 +233,13 @@ class Puppeteer::DOMWorld
   # @param url [String?]
   # @param path [String?]
   # @param content [String?]
+  # @param id [String?]
   # @param type [String?]
-  def add_script_tag(url: nil, path: nil, content: nil, type: nil)
+  def add_script_tag(url: nil, path: nil, content: nil, id: nil, type: nil)
     if url
       begin
         return execution_context.
-          evaluate_handle(ADD_SCRIPT_URL, url, type || '').
+          evaluate_handle(ADD_SCRIPT_URL, url, id, type || '').
           as_element
       rescue Puppeteer::ExecutionContext::EvaluationError # for Chrome
         raise "Loading script from #{url} failed"
@@ -251,13 +252,13 @@ class Puppeteer::DOMWorld
       contents = File.read(path)
       contents += "//# sourceURL=#{path.gsub(/\n/, '')}"
       return execution_context.
-        evaluate_handle(ADD_SCRIPT_CONTENT, contents, type || '').
+        evaluate_handle(ADD_SCRIPT_CONTENT, contents, id, type || 'text/javascript').
         as_element
     end
 
     if content
       return execution_context.
-        evaluate_handle(ADD_SCRIPT_CONTENT, content, type || '').
+        evaluate_handle(ADD_SCRIPT_CONTENT, content, id, type || 'text/javascript').
         as_element
     end
 
@@ -265,11 +266,11 @@ class Puppeteer::DOMWorld
   end
 
   ADD_SCRIPT_URL = <<~JAVASCRIPT
-  async (url, type) => {
+  async (url, id, type) => {
     const script = document.createElement('script');
     script.src = url;
-    if (type)
-      script.type = type;
+    if (id) script.id = id;
+    if (type) script.type = type;
     const promise = new Promise((res, rej) => {
       script.onload = res;
       script.onerror = rej;
@@ -281,11 +282,11 @@ class Puppeteer::DOMWorld
   JAVASCRIPT
 
   ADD_SCRIPT_CONTENT = <<~JAVASCRIPT
-  (content, type) => {
-    if (type === undefined) type = 'text/javascript';
+  (content, id, type) => {
     const script = document.createElement('script');
     script.type = type;
     script.text = content;
+    if (id) script.id = id;
     let error = null;
     script.onerror = e => error = e;
     document.head.appendChild(script);

data/lib/puppeteer/element_handle/offset.rb

@@ -0,0 +1,28 @@
+class Puppeteer::ElementHandle < Puppeteer::JSHandle
+  # A class to represent (x, y)-offset coordinates
+  class Offset
+    def initialize(x:, y:)
+      @x = x
+      @y = y
+    end
+
+    def self.from(offset)
+      case offset
+      when nil
+        nil
+      when Hash
+        if offset[:x] && offset[:y]
+          Offset.new(x: offset[:x], y: offset[:y])
+        else
+          raise ArgumentError.new('offset parameter must have x, y coordinates')
+        end
+      when Offset
+        offset
+      else
+        raise ArgumentError.new('Offset.from(Hash|Offset)')
+      end
+    end
+
+    attr_reader :x, :y
+  end
+end

data/lib/puppeteer/element_handle/point.rb

@@ -21,6 +21,17 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
       )
     end
 
+    def ==(other)
+      case other
+      when Hash
+        @x == other[:x] && @y == other[:y]
+      when Point
+        @x == other.x && @y == other.y
+      else
+        super
+      end
+    end
+
     attr_reader :x, :y
   end
 end

data/lib/puppeteer/element_handle.rb

@@ -1,5 +1,6 @@
 require_relative './element_handle/bounding_box'
 require_relative './element_handle/box_model'
+require_relative './element_handle/offset'
 require_relative './element_handle/point'
 
 class Puppeteer::ElementHandle < Puppeteer::JSHandle
@@ -79,7 +80,9 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     end
   end
 
-  def clickable_point
+  def clickable_point(offset = nil)
+    offset_param = Offset.from(offset)
+
     result =
       begin
         @remote_object.content_quads(@client)
@@ -105,6 +108,19 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
       raise ElementNotVisibleError.new
     end
 
+    if offset_param
+      # Return the point of the first quad identified by offset.
+      quad = quads.first
+      min_x = quad.map(&:x).min
+      min_y = quad.map(&:y).min
+      if min_x && min_y
+        return Point.new(
+          x: min_x + offset_param.x,
+          y: min_y + offset_param.y,
+        )
+      end
+    end
+
     # Return the middle point of the first quad.
     quads.first.reduce(:+) / 4
   end
@@ -139,14 +155,56 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   # @param delay [Number]
   # @param button [String] "left"|"right"|"middle"
   # @param click_count [Number]
-  def click(delay: nil, button: nil, click_count: nil)
+  # @param offset [Hash]
+  def click(delay: nil, button: nil, click_count: nil, offset: nil)
     scroll_into_view_if_needed
-    point = clickable_point
+    point = clickable_point(offset)
     @page.mouse.click(point.x, point.y, delay: delay, button: button, click_count: click_count)
   end
 
   define_async_method :async_click
 
+  class DragInterceptionNotEnabledError < StandardError
+    def initialize
+      super('Drag Interception is not enabled!')
+    end
+  end
+
+  def drag(x:, y:)
+    unless @page.drag_interception_enabled?
+      raise DragInterceptionNotEnabledError.new
+    end
+    scroll_into_view_if_needed
+    start = clickable_point
+    @page.mouse.drag(start, Point.new(x: x, y: y))
+  end
+
+  def drag_enter(data)
+    scroll_into_view_if_needed
+    target = clickable_point
+    @page.mouse.drag_enter(target, data)
+  end
+
+  def drag_over(data)
+    scroll_into_view_if_needed
+    target = clickable_point
+    @page.mouse.drag_over(target, data)
+  end
+
+  def drop(data)
+    scroll_into_view_if_needed
+    target = clickable_point
+    @page.mouse.drop(target, data)
+  end
+
+  # @param target [ElementHandle]
+  def drag_and_drop(target, delay: nil)
+    scroll_into_view_if_needed
+    start_point = clickable_point
+    target_point = target.clickable_point
+    @page.mouse.drag_and_drop(start_point, target_point, delay: delay)
+  end
+
   # @return [Array<String>]
   def select(*values)
     if nonstring = values.find { |value| !value.is_a?(String) }
@@ -395,10 +453,12 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   define_async_method :async_Sx
 
   # in JS, #isIntersectingViewport.
+  # @param threshold [Float|nil]
   # @return [Boolean]
-  def intersecting_viewport?
+  def intersecting_viewport?(threshold: nil)
+    option_threshold = threshold || 0
     js = <<~JAVASCRIPT
-    async element => {
+    async (element, threshold) => {
       const visibleRatio = await new Promise(resolve => {
         const observer = new IntersectionObserver(entries => {
           resolve(entries[0].intersectionRatio);
@@ -406,11 +466,12 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
         });
         observer.observe(element);
       });
-      return visibleRatio > 0;
+      if (threshold === 1) return visibleRatio === 1;
+      else return visibleRatio > threshold;
     }
     JAVASCRIPT
 
-    evaluate(js)
+    evaluate(js, option_threshold)
   end
 
   # @param quad [Array<Point>]

data/lib/puppeteer/frame.rb

@@ -28,7 +28,7 @@ class Puppeteer::Frame
   # @param rederer [String]
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
-  # @return [Puppeteer::Response]
+  # @return [Puppeteer::HTTPResponse]
   def goto(url, referer: nil, timeout: nil, wait_until: nil)
     @frame_manager.navigate_frame(self, url, referer: referer, timeout: timeout, wait_until: wait_until)
   end
@@ -157,8 +157,9 @@ class Puppeteer::Frame
   # @param path [String?]
   # @param content [String?]
   # @param type [String?]
-  def add_script_tag(url: nil, path: nil, content: nil, type: nil)
-    @main_world.add_script_tag(url: url, path: path, content: content, type: type)
+  # @param id [String?]
+  def add_script_tag(url: nil, path: nil, content: nil, type: nil, id: nil)
+    @main_world.add_script_tag(url: url, path: path, content: content, type: type, id: id)
   end
 
   # @param url [String?]

data/lib/puppeteer/frame_manager.rb

@@ -82,7 +82,7 @@ class Puppeteer::FrameManager
   # @param frame [Puppeteer::Frame]
   # @param url [String]
   # @param {!{referer?: string, timeout?: number, waitUntil?: string|!Array<string>}=} options
-  # @return [Puppeteer::Response]
+  # @return [Puppeteer::HTTPResponse]
   def navigate_frame(frame, url, referer: nil, timeout: nil, wait_until: nil)
     assert_no_legacy_navigation_options(wait_until: wait_until)
 
@@ -132,7 +132,7 @@ class Puppeteer::FrameManager
 
   # @param timeout [number|nil]
   # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
-  # @return [Puppeteer::Response]
+  # @return [Puppeteer::HTTPResponse]
   def wait_for_frame_navigation(frame, timeout: nil, wait_until: nil)
     assert_no_legacy_navigation_options(wait_until: wait_until)
 

data/lib/puppeteer/{request.rb → http_request.rb}

@@ -1,4 +1,4 @@
-class Puppeteer::Request
+class Puppeteer::HTTPRequest
   include Puppeteer::DebugPrint
   include Puppeteer::IfPresent
 
@@ -16,7 +16,7 @@ class Puppeteer::Request
       @request.instance_variable_get(:@interception_id)
     end
 
-    # @param response [Puppeteer::Response]
+    # @param response [Puppeteer::HTTPResponse]
     def response=(response)
       @request.instance_variable_set(:@response, response)
     end
@@ -56,6 +56,12 @@ class Puppeteer::Request
     @post_data = event['request']['postData']
     @frame = frame
     @redirect_chain = redirect_chain
+    @continue_request_overrides = {}
+    @current_strategy = 'none'
+    @current_priority = nil
+    @intercept_actions = []
+    @initiator = event['initiator']
+
     @headers = {}
     event['request']['headers'].each do |key, value|
       @headers[key.downcase] = value
@@ -68,6 +74,76 @@ class Puppeteer::Request
   attr_reader :internal
   attr_reader :url, :resource_type, :method, :post_data, :headers, :response, :frame
 
+  private def assert_interception_allowed
+    unless @allow_interception
+      raise InterceptionNotEnabledError.new
+    end
+  end
+
+  private def assert_interception_not_handled
+    if @interception_handled
+      raise AlreadyHandledError.new
+    end
+  end
+
+  # @returns the `ContinueRequestOverrides` that will be used
+  # if the interception is allowed to continue (ie, `abort()` and
+  # `respond()` aren't called).
+  def continue_request_overrides
+    assert_interception_allowed
+    @continue_request_overrides
+  end
+
+  # @returns The `ResponseForRequest` that gets used if the
+  # interception is allowed to respond (ie, `abort()` is not called).
+  def response_for_request
+    assert_interception_allowed
+    @response_for_request
+  end
+
+  # @returns the most recent reason for aborting the request
+  def abort_error_reason
+    assert_interception_allowed
+    @abort_error_reason
+  end
+
+  # @returns An array of the current intercept resolution strategy and priority
+  # `[strategy,priority]`. Strategy is one of: `abort`, `respond`, `continue`,
+  #  `disabled`, `none`, or `already-handled`.
+  def intercept_resolution
+    if !@allow_interception
+      ['disabled']
+    elsif @interception_handled
+      ['already-handled']
+    else
+      [@current_strategy, @current_priority]
+    end
+  end
+
+  # Adds an async request handler to the processing queue.
+  # Deferred handlers are not guaranteed to execute in any particular order,
+  # but they are guarnateed to resolve before the request interception
+  # is finalized.
+  #
+  # @param pending_handler [Proc]
+  def enqueue_intercept_action(pending_handler)
+    @intercept_actions << pending_handler
+  end
+
+  # Awaits pending interception handlers and then decides how to fulfill
+  # the request interception.
+  def finalize_interceptions
+    @intercept_actions.each(&:call)
+    case @intercept_resolution
+    when :abort
+      abort_impl(**@abort_error_reason)
+    when :respond
+      respond_impl(**@response_for_request)
+    when :continue
+      continue_impl(@continue_request_overrides)
+    end
+  end
+
   def navigation_request?
     @is_navigation_request
   end
@@ -116,24 +192,43 @@ class Puppeteer::Request
   #   end
   #
   # @param error_code [String|Symbol]
-  def continue(url: nil, method: nil, post_data: nil, headers: nil)
+  def continue(url: nil, method: nil, post_data: nil, headers: nil, priority: nil)
     # Request interception is not supported for data: urls.
     return if @url.start_with?('data:')
 
-    unless @allow_interception
-      raise InterceptionNotEnabledError.new
-    end
-    if @interception_handled
-      raise AlreadyHandledError.new
-    end
-    @interception_handled = true
+    assert_interception_allowed
+    assert_interception_not_handled
 
     overrides = {
       url: url,
       method: method,
-      post_data: post_data,
+      postData: post_data,
       headers: headers_to_array(headers),
     }.compact
+
+    if priority.nil?
+      continue_impl(overrides)
+      return
+    end
+
+    @continue_request_overrides = overrides
+    if @current_priority.nil? || priority > @current_priority
+      @current_strategy = :continue
+      @current_priority = priority
+      return
+    end
+
+    if priority == @current_priority
+      if @current_strategy == :abort || @current_strategy == :respond
+        return
+      end
+      @current_strategy = :continue
+    end
+  end
+
+  private def continue_impl(overrides)
+    @interception_handled = true
+
     begin
       @client.send_message('Fetch.continueRequest',
         requestId: @interception_id,
@@ -162,16 +257,40 @@ class Puppeteer::Request
   # @param headers [Hash<String, String>]
   # @param content_type [String]
   # @param body [String]
-  def respond(status: nil, headers: nil, content_type: nil, body: nil)
+  def respond(status: nil, headers: nil, content_type: nil, body: nil, priority: nil)
     # Mocking responses for dataURL requests is not currently supported.
     return if @url.start_with?('data:')
 
-    unless @allow_interception
-      raise InterceptionNotEnabledError.new
+    assert_interception_allowed
+    assert_interception_not_handled
+
+    if priority.nil?
+      respond_impl(status: status, headers: headers, content_type: content_type, body: body)
+      return
     end
-    if @interception_handled
-      raise AlreadyHandledError.new
+
+    @response_for_request = {
+      status: status,
+      headers: headers,
+      content_type: content_type,
+      body: body,
+    }
+
+    if @current_priority.nil? || priority > @current_priority
+      @current_strategy = :respond
+      @current_priority = priority
+      return
+    end
+
+    if priority == @current_priority
+      if @current_strategy == :abort
+        return
+      end
+      @current_strategy = :respond
     end
+  end
+
+  private def respond_impl(status: nil, headers: nil, content_type: nil, body: nil)
     @interception_handled = true
 
     mock_response_headers = {}
@@ -191,6 +310,7 @@ class Puppeteer::Request
       responseHeaders: headers_to_array(mock_response_headers),
       body: if_present(body) { |mock_body| Base64.strict_encode64(mock_body) },
     }.compact
+
     begin
       @client.send_message('Fetch.fulfillRequest',
         requestId: @interception_id,
@@ -216,7 +336,7 @@ class Puppeteer::Request
   #   end
   #
   # @param error_code [String|Symbol]
-  def abort(error_code: :failed)
+  def abort(error_code: :failed, priority: nil)
     # Request interception is not supported for data: urls.
     return if @url.start_with?('data:')
 
@@ -224,12 +344,21 @@ class Puppeteer::Request
     unless error_reason
       raise ArgumentError.new("Unknown error code: #{error_code}")
     end
-    unless @allow_interception
-      raise InterceptionNotEnabledError.new
+    assert_interception_allowed
+    assert_interception_not_handled
+
+    if priority.nil?
+      abort_impl(error_reason)
     end
-    if @interception_handled
-      raise AlreadyHandledError.new
+    @abort_error_reason = error_reason
+
+    if @current_priority.nil? || priority > @current_priority
+      @current_strategy = :abort
+      @current_priority = priority
     end
+  end
+
+  private def abort_impl(error_reason)
     @interception_handled = true
 
     begin

data/lib/puppeteer/{response.rb → http_response.rb}

@@ -1,6 +1,6 @@
 require 'json'
 
-class Puppeteer::Response
+class Puppeteer::HTTPResponse
   include Puppeteer::IfPresent
 
   class Redirected < StandardError
@@ -29,7 +29,7 @@ class Puppeteer::Response
   end
 
   # @param client [Puppeteer::CDPSession]
-  # @param request [Puppeteer::Request]
+  # @param request [Puppeteer::HTTPRequest]
   # @param response_payload [Hash]
   def initialize(client, request, response_payload)
     @client = client