puppeteer-ruby 0.0.5 → 0.0.6

data/docs/top-level-namespace.html

@@ -116,7 +116,7 @@
 </div>
 
       <div id="footer">
-  Generated on Sun Apr 26 15:52:55 2020 by
+  Generated on Mon May 25 23:22:48 2020 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
   0.9.24 (ruby-2.6.3).
 </div>

data/lib/puppeteer/cdp_session.rb

@@ -1,4 +1,5 @@
 class Puppeteer::CDPSession
+  include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
   using Puppeteer::AsyncAwaitBehavior
 
@@ -12,6 +13,7 @@ class Puppeteer::CDPSession
     @connection = connection
     @target_type = target_type
     @session_id = session_id
+    @pending_messages = {}
   end
 
   attr_reader :connection
@@ -32,7 +34,13 @@ class Puppeteer::CDPSession
     end
     id = @connection.raw_send(message: { sessionId: @session_id, method: method, params: params })
     promise = resolvable_future
-    @callbacks[id] = Puppeteer::Connection::MessageCallback.new(method: method, promise: promise)
+    callback = Puppeteer::Connection::MessageCallback.new(method: method, promise: promise)
+    if pending_message = @pending_messages.delete(id)
+      debug_puts "Pending message (id: #{id}) is handled"
+      callback_with_message(callback, pending_message)
+    else
+      @callbacks[id] = callback
+    end
     promise
   end
 
@@ -40,23 +48,37 @@ class Puppeteer::CDPSession
   def handle_message(message)
     if message['id']
       if callback = @callbacks.delete(message['id'])
-        if message['error']
-          callback.reject(
-            Puppeteer::Connection::ProtocolError.new(
-              method: callback.method,
-              error_message: message['error']['message'],
-              error_data: message['error']['data']))
-        else
-          callback.resolve(message['result'])
-        end
+        callback_with_message(callback, message)
       else
-        raise Error.new("unknown id: #{message['id']}")
+        debug_puts "unknown id: #{id}. Store it into pending message"
+
+        # RECV is often notified before SEND.
+        # Wait about 10 frames before throwing an error.
+        message_id = message['id']
+        @pending_messages[message_id] = message
+        Concurrent::Promises.schedule(0.16, message_id) do |id|
+          if @pending_messages.delete(id)
+            raise Error.new("unknown id: #{id}")
+          end
+        end
       end
     else
       emit_event message['method'], message['params']
     end
   end
 
+  private def callback_with_message(callback, message)
+    if message['error']
+      callback.reject(
+        Puppeteer::Connection::ProtocolError.new(
+          method: callback.method,
+          error_message: message['error']['message'],
+          error_data: message['error']['data']))
+    else
+      callback.resolve(message['result'])
+    end
+  end
+
   def detach
     if !@connection
       raise Error.new("Session already detarched. Most likely the #{@target_type} has been closed.")

data/lib/puppeteer/dom_world.rb

@@ -19,6 +19,11 @@ class Puppeteer::DOMWorld
 
   attr_reader :frame
 
+  # only used in Puppeteer::WaitTask#initialize
+  def _wait_tasks
+    @wait_tasks
+  end
+
   # @param {?Puppeteer.ExecutionContext} context
   def context=(context)
     # D, [2020-04-12T22:45:03.938754 #46154] DEBUG -- : RECV << {"method"=>"Runtime.executionContextCreated", "params"=>{"context"=>{"id"=>3, "origin"=>"https://github.com", "name"=>"", "auxData"=>{"isDefault"=>true, "type"=>"default", "frameId"=>"3AD7F1E82BCBA88BFE31D03BC49FF6CB"}}}, "sessionId"=>"636CEF0C4FEAFC4FE815E9E7B5F7BA68"}
@@ -35,8 +40,7 @@ class Puppeteer::DOMWorld
         @context_promise = resolvable_future
       end
       @context_promise.fulfill(context)
-    #   for (const waitTask of this._waitTasks)
-    #     waitTask.rerun();
+      @wait_tasks.each(&:async_rerun)
     else
       raise ArgumentError.new("context should now be nil. Use #delete_context for clearing document.")
     end
@@ -364,45 +368,37 @@ class Puppeteer::DOMWorld
   #   return result;
   # }
 
-  # /**
-  #  * @param {string} selector
-  #  */
-  # async tap(selector) {
-  #   const handle = await this.$(selector);
-  #   assert(handle, 'No node found for selector: ' + selector);
-  #   await handle.tap();
-  #   await handle.dispose();
-  # }
+  # @param selector [String]
+  def tap(selector)
+    handle = S(selector)
+    handle.tap
+    handle.dispose
+  end
 
-  # /**
-  #  * @param {string} selector
-  #  * @param {string} text
-  #  * @param {{delay: (number|undefined)}=} options
-  #  */
-  # async type(selector, text, options) {
-  #   const handle = await this.$(selector);
-  #   assert(handle, 'No node found for selector: ' + selector);
-  #   await handle.type(text, options);
-  #   await handle.dispose();
-  # }
+  # @param selector [String]
+  # @param text [String]
+  # @param delay [Number]
+  def type_text(selector, text, delay: nil)
+    handle = S(selector)
+    handle.type_text(text, delay: delay)
+    handle.dispose
+  end
 
-  # /**
-  #  * @param {string} selector
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  #  * @return {!Promise<?Puppeteer.ElementHandle>}
-  #  */
-  # waitForSelector(selector, options) {
-  #   return this._waitForSelectorOrXPath(selector, false, options);
-  # }
+  # @param selector [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
+  def wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
+    wait_for_selector_or_xpath(selector, false, visible: visible, hidden: hidden, timeout: timeout)
+  end
 
-  # /**
-  #  * @param {string} xpath
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  #  * @return {!Promise<?Puppeteer.ElementHandle>}
-  #  */
-  # waitForXPath(xpath, options) {
-  #   return this._waitForSelectorOrXPath(xpath, true, options);
-  # }
+  # @param xpath [String]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
+  def wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
+    wait_for_selector_or_xpath(xpath, true, visible: visible, hidden: hidden, timeout: timeout)
+  end
 
   # /**
   #  * @param {Function|string} pageFunction
@@ -424,57 +420,68 @@ class Puppeteer::DOMWorld
   #   return this.evaluate(() => document.title);
   # }
 
-  # /**
-  #  * @param {string} selectorOrXPath
-  #  * @param {boolean} isXPath
-  #  * @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  #  * @return {!Promise<?Puppeteer.ElementHandle>}
-  #  */
-  # async _waitForSelectorOrXPath(selectorOrXPath, isXPath, options = {}) {
-  #   const {
-  #     visible: waitForVisible = false,
-  #     hidden: waitForHidden = false,
-  #     timeout = this._timeoutSettings.timeout(),
-  #   } = options;
-  #   const polling = waitForVisible || waitForHidden ? 'raf' : 'mutation';
-  #   const title = `${isXPath ? 'XPath' : 'selector'} "${selectorOrXPath}"${waitForHidden ? ' to be hidden' : ''}`;
-  #   const waitTask = new WaitTask(this, predicate, title, polling, timeout, selectorOrXPath, isXPath, waitForVisible, waitForHidden);
-  #   const handle = await waitTask.promise;
-  #   if (!handle.asElement()) {
-  #     await handle.dispose();
-  #     return null;
-  #   }
-  #   return handle.asElement();
+  # @param selector_or_xpath [String]
+  # @param is_xpath [Boolean]
+  # @param visible [Boolean] Wait for element visible (not 'display: none' nor 'visibility: hidden') on true. default to false.
+  # @param hidden [Boolean] Wait for element invisible ('display: none' nor 'visibility: hidden') on true. default to false.
+  # @param timeout [Integer]
+  private def wait_for_selector_or_xpath(selector_or_xpath, is_xpath, visible: nil, hidden: nil, timeout: nil)
+    option_wait_for_visible = visible || false
+    option_wait_for_hidden = hidden || false
+    option_timeout = timeout || @timeout_settings.timeout
+
+    polling =
+      if option_wait_for_visible || option_wait_for_hidden
+        'raf'
+      else
+        'mutation'
+      end
+    title = "#{is_xpath ? :XPath : :selector} #{selector_or_xpath}#{option_wait_for_hidden ? 'to be hidden' : ''}"
+
+    wait_task = Puppeteer::WaitTask.new(
+      dom_world: self,
+      predicate_body: "return (#{PREDICATE})(...args)",
+      title: title,
+      polling: polling,
+      timeout: option_timeout,
+      args: [selector_or_xpath, is_xpath, option_wait_for_visible, option_wait_for_hidden],
+    )
+    handle = wait_task.await_promise
+    unless handle.as_element
+      handle.dispose
+      return nil
+    end
+    handle.as_element
+  end
 
-  #   /**
-  #    * @param {string} selectorOrXPath
-  #    * @param {boolean} isXPath
-  #    * @param {boolean} waitForVisible
-  #    * @param {boolean} waitForHidden
-  #    * @return {?Node|boolean}
-  #    */
-  #   function predicate(selectorOrXPath, isXPath, waitForVisible, waitForHidden) {
-  #     const node = isXPath
-  #       ? document.evaluate(selectorOrXPath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue
-  #       : document.querySelector(selectorOrXPath);
-  #     if (!node)
-  #       return waitForHidden;
-  #     if (!waitForVisible && !waitForHidden)
-  #       return node;
-  #     const element = /** @type {Element} */ (node.nodeType === Node.TEXT_NODE ? node.parentElement : node);
-
-  #     const style = window.getComputedStyle(element);
-  #     const isVisible = style && style.visibility !== 'hidden' && hasVisibleBoundingBox();
-  #     const success = (waitForVisible === isVisible || waitForHidden === !isVisible);
-  #     return success ? node : null;
-
-  #     /**
-  #      * @return {boolean}
-  #      */
-  #     function hasVisibleBoundingBox() {
-  #       const rect = element.getBoundingClientRect();
-  #       return !!(rect.top || rect.bottom || rect.width || rect.height);
-  #     }
-  #   }
-  # }
+  PREDICATE = <<~JAVASCRIPT
+  /**
+    * @param {string} selectorOrXPath
+    * @param {boolean} isXPath
+    * @param {boolean} waitForVisible
+    * @param {boolean} waitForHidden
+    * @return {?Node|boolean}
+    */
+  function _(selectorOrXPath, isXPath, waitForVisible, waitForHidden) {
+      const node = isXPath
+          ? document.evaluate(selectorOrXPath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue
+          : document.querySelector(selectorOrXPath);
+      if (!node)
+          return waitForHidden;
+      if (!waitForVisible && !waitForHidden)
+          return node;
+      const element = /** @type {Element} */ (node.nodeType === Node.TEXT_NODE ? node.parentElement : node);
+      const style = window.getComputedStyle(element);
+      const isVisible = style && style.visibility !== 'hidden' && hasVisibleBoundingBox();
+      const success = (waitForVisible === isVisible || waitForHidden === !isVisible);
+      return success ? node : null;
+      /**
+        * @return {boolean}
+        */
+      function hasVisibleBoundingBox() {
+          const rect = element.getBoundingClientRect();
+          return !!(rect.top || rect.bottom || rect.width || rect.height);
+      }
+  }
+  JAVASCRIPT
 end

data/lib/puppeteer/element_handle.rb

@@ -37,20 +37,8 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
           return 'Node is detached from document';
         if (element.nodeType !== Node.ELEMENT_NODE)
           return 'Node is not of type HTMLElement';
-        // force-scroll if page's javascript is disabled.
-        if (!pageJavascriptEnabled) {
-          element.scrollIntoView({block: 'center', inline: 'center', behavior: 'instant'});
-          return false;
-        }
-        const visibleRatio = await new Promise(resolve => {
-          const observer = new IntersectionObserver(entries => {
-            resolve(entries[0].intersectionRatio);
-            observer.disconnect();
-          });
-          observer.observe(element);
-        });
-        if (visibleRatio !== 1.0)
-          element.scrollIntoView({block: 'center', inline: 'center', behavior: 'instant'});
+
+        element.scrollIntoViewIfNeeded({block: 'center', inline: 'center', behavior: 'instant'});
         return false;
       }
     JAVASCRIPT
@@ -58,6 +46,9 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     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
 
   class Point
@@ -157,14 +148,12 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     @page.mouse.click(point.x, point.y, delay: delay, button: button, click_count: click_count)
   end
 
-  #  /**
-  #   * @param {!{delay?: number, button?: "left"|"right"|"middle", clickCount?: number}=} options
-  #   */
-  #  async click(options) {
-  #    await this._scrollIntoViewIfNeeded();
-  #    const {x, y} = await this._clickablePoint();
-  #    await this._page.mouse.click(x, y, options);
-  #  }
+  # @param delay [Number]
+  # @param button [String] "left"|"right"|"middle"
+  # @param click_count [Number]
+  async def async_click(delay: nil, button: nil, click_count: nil)
+    click(delay: delay, button: button, click_count: click_count)
+  end
 
   #  /**
   #   * @param {!Array<string>} values
@@ -228,11 +217,11 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
   #    }, files);
   #  }
 
-  #  async tap() {
-  #    await this._scrollIntoViewIfNeeded();
-  #    const {x, y} = await this._clickablePoint();
-  #    await this._page.touchscreen.tap(x, y);
-  #  }
+  def tap
+    scroll_into_view_if_needed
+    point = clickable_point
+    @page.touchscreen.tap(point.x, point.y)
+  end
 
 
   def focus
@@ -419,33 +408,26 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
     result
   end
 
-  #  /**
-  #   * @param {string} expression
-  #   * @return {!Promise<!Array<!ElementHandle>>}
-  #   */
-  #  async $x(expression) {
-  #    const arrayHandle = await this.evaluateHandle(
-  #        (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;
-  #        },
-  #        expression
-  #    );
-  #    const properties = await arrayHandle.getProperties();
-  #    await arrayHandle.dispose();
-  #    const result = [];
-  #    for (const property of properties.values()) {
-  #      const elementHandle = property.asElement();
-  #      if (elementHandle)
-  #        result.push(elementHandle);
-  #    }
-  #    return result;
-  #  }
+  # `$x()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param expression [String]
+  # @return [Array<ElementHandle>]
+  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
 
   #  /**
   #   * @returns {!Promise<boolean>}

data/lib/puppeteer/execution_context.rb

@@ -122,7 +122,7 @@ class Puppeteer::ExecutionContext
       remote_object = Puppeteer::RemoteObject.new(result['result'])
 
       if exception_details
-        raise EvaluationError.new("Evaluation failed: #{exceptionDetails}")
+        raise EvaluationError.new("Evaluation failed: #{exception_details}")
       end
 
       if @return_by_value
@@ -216,20 +216,26 @@ class Puppeteer::ExecutionContext
   #   return createJSHandle(this, response.objects);
   # }
 
-  # /**
-  #  * @param {Puppeteer.ElementHandle} elementHandle
-  #  * @return {Promise<Puppeteer.ElementHandle>}
-  #  */
-  # async _adoptElementHandle(elementHandle) {
-  #   assert(elementHandle.executionContext() !== this, 'Cannot adopt handle that already belongs to this execution context');
-  #   assert(this._world, 'Cannot adopt handle without DOMWorld');
-  #   const nodeInfo = await this._client.send('DOM.describeNode', {
-  #     objectId: elementHandle._remoteObject.objectId,
-  #   });
-  #   const {object} = await this._client.send('DOM.resolveNode', {
-  #     backendNodeId: nodeInfo.node.backendNodeId,
-  #     executionContextId: this._contextId,
-  #   });
-  #   return /** @type {Puppeteer.ElementHandle}*/(createJSHandle(this, object));
-  # }
+  # @param element_handle [Puppeteer::ElementHandle]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_element_handle(element_handle)
+    if element_handle.execution_context == self
+      raise ArgumentError.new('Cannot adopt handle that already belongs to this execution context')
+    end
+
+    unless @world
+      raise 'Cannot adopt handle without DOMWorld'
+    end
+
+    node_info = element_handle.remote_object.node_info(@client)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: node_info["node"]["backendNodeId"],
+      executionContextId: @context_id,
+    )
+
+    Puppeteer::JSHandle.create(
+      context: self,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
 end