puppeteer-ruby 0.0.5 → 0.0.6

data/lib/puppeteer/frame.rb

@@ -173,11 +173,11 @@ class Puppeteer::Frame
     @secondary_world.tap(selector)
   end
 
-  # @param {string} selector
-  # @param {string} text
-  # @param {{delay: (number|undefined)}=} options
-  def type(selector, text, delay: nil)
-    @main_world.type(selector, text, delay: delay)
+  # @param selector [String]
+  # @param text [String]
+  # @param delay [Number]
+  def type_text(selector, text, delay: nil)
+    @main_world.type_text(selector, text, delay: delay)
   end
 
   # /**
@@ -202,9 +202,10 @@ class Puppeteer::Frame
   #   return Promise.reject(new Error('Unsupported target type: ' + (typeof selectorOrFunctionOrTimeout)));
   # }
 
-  # @param {string} selector
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @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)
     handle = @secondary_world.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
     if !handle
@@ -216,9 +217,10 @@ class Puppeteer::Frame
     result
   end
 
-  # @param {string} xpath
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @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)
     handle = @secondary_world.wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
     if !handle

data/lib/puppeteer/page.rb

@@ -973,11 +973,11 @@ class Puppeteer::Page
     main_frame.tap(selector)
   end
 
-  # @param {string} selector
-  # @param {string} text
-  # @param {{delay: (number|undefined)}=} options
-  def type(selector, text, delay: nil)
-    main_frame.type(selector, text, delay: delay)
+  # @param selector [String]
+  # @param text [String]
+  # @param delay [Number]
+  def type_text(selector, text, delay: nil)
+    main_frame.type_text(selector, text, delay: delay)
   end
 
   # /**
@@ -990,20 +990,38 @@ class Puppeteer::Page
   #   return this.mainFrame().waitFor(selectorOrFunctionOrTimeout, options, ...args);
   # }
 
-  # @param {string} selector
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @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)
     main_frame.wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
   end
 
-  # @param {string} xpath
-  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
-  # @return {!Promise<?Puppeteer.ElementHandle>}
+  # @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]
+  async def async_wait_for_selector(selector, visible: nil, hidden: nil, timeout: nil)
+    wait_for_selector(selector, visible: visible, hidden: hidden, timeout: timeout)
+  end
+
+  # @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)
     main_frame.wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
   end
 
+  # @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]
+  async def async_wait_for_xpath(xpath, visible: nil, hidden: nil, timeout: nil)
+    wait_for_xpath(xpath, visible: visible, hidden: hidden, timeout: timeout)
+  end
+
   # @param {Function|string} pageFunction
   # @param {!{polling?: string|number, timeout?: number}=} options
   # @param {!Array<*>} args

data/lib/puppeteer/version.rb

@@ -1,3 +1,3 @@
 class Puppeteer
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/lib/puppeteer/wait_task.rb

@@ -1,6 +1,188 @@
 class Puppeteer::WaitTask
+  using Puppeteer::AsyncAwaitBehavior
+
   class TerminatedError < StandardError; end
 
-  def initialize
+  class TimeoutError < StandardError
+    def initialize(title:, timeout:)
+      super("waiting for #{title} failed: timeout #{timeout}ms exceeded")
+    end
+  end
+
+  def initialize(dom_world:, predicate_body:, title:, polling:, timeout:, args: [])
+    if polling.is_a?(String)
+      if polling != 'raf' && polling != 'mutation'
+        raise ArgumentError.new("Unknown polling option: #{polling}")
+      end
+    elsif polling.is_a?(Numeric)
+      unless polling.positive?
+        raise ArgumentError.new("Cannot poll with non-positive interval: #{polling}")
+      end
+    else
+      raise ArgumentError.new("Unknown polling options: #{polling}")
+    end
+
+    @dom_world = dom_world
+    @polling = polling
+    @timeout = timeout
+    @predicate_body = predicate_body
+    @args = args
+    @run_count = 0
+    @dom_world._wait_tasks.add(self)
+    @promise = resolvable_future
+
+    # Since page navigation requires us to re-install the pageScript, we should track
+    # timeout on our end.
+    if timeout
+      timeout_error = TimeoutError.new(title: title, timeout: timeout)
+      Concurrent::Promises.schedule(timeout / 1000.0) { terminate(timeout_error) unless @timeout_cleared }
+    end
+    async_rerun
+  end
+
+  # @return [Puppeteer::JSHandle]
+  def await_promise
+    @promise.value!
+  end
+
+  def terminate(error)
+    @terminated = true
+    @promise.reject(error)
+    cleanup
+  end
+
+  def rerun
+    run_count = (@run_count += 1)
+    begin
+      success = @dom_world.execution_context.evaluate_handle(
+        WAIT_FOR_PREDICATE_PAGE_FUNCTION,
+        @predicate_body,
+        @polling,
+        @timeout,
+        *@args,
+      )
+    rescue => err
+      error = err
+    end
+
+    if @terminated || run_count != @run_count
+      if success
+        success.dispose
+      end
+      return
+    end
+
+    # Ignore timeouts in pageScript - we track timeouts ourselves.
+    # If the frame's execution context has already changed, `frame.evaluate` will
+    # throw an error - ignore this predicate run altogether.
+    if !error && (@dom_world.evaluate("s => !s", success) rescue true)
+      success.dispose
+      return
+    end
+
+    # When the page is navigated, the promise is rejected.
+    # We will try again in the new execution context.
+    if error && error.message.include?('Execution context was destroyed')
+      return
+    end
+
+    # We could have tried to evaluate in a context which was already
+    # destroyed.
+    if error && error.message.include?('Cannot find context with specified id')
+      return
+    end
+
+    if error
+      @promise.reject(error)
+    else
+      @promise.fulfill(success)
+    end
+
+    cleanup
   end
+
+  private def cleanup
+    @timeout_cleared = true
+    @dom_world._wait_tasks.delete(self)
+  end
+
+  private async def async_rerun
+    rerun
+  end
+
+  WAIT_FOR_PREDICATE_PAGE_FUNCTION = <<~JAVASCRIPT
+  async function _(predicateBody, polling, timeout, ...args) {
+      const predicate = new Function('...args', predicateBody);
+      let timedOut = false;
+      if (timeout)
+          setTimeout(() => (timedOut = true), timeout);
+      if (polling === 'raf')
+          return await pollRaf();
+      if (polling === 'mutation')
+          return await pollMutation();
+      if (typeof polling === 'number')
+          return await pollInterval(polling);
+      /**
+       * @return {!Promise<*>}
+       */
+      function pollMutation() {
+          const success = predicate(...args);
+          if (success)
+              return Promise.resolve(success);
+          let fulfill;
+          const result = new Promise((x) => (fulfill = x));
+          const observer = new MutationObserver(() => {
+              if (timedOut) {
+                  observer.disconnect();
+                  fulfill();
+              }
+              const success = predicate(...args);
+              if (success) {
+                  observer.disconnect();
+                  fulfill(success);
+              }
+          });
+          observer.observe(document, {
+              childList: true,
+              subtree: true,
+              attributes: true,
+          });
+          return result;
+      }
+      function pollRaf() {
+          let fulfill;
+          const result = new Promise((x) => (fulfill = x));
+          onRaf();
+          return result;
+          function onRaf() {
+              if (timedOut) {
+                  fulfill();
+                  return;
+              }
+              const success = predicate(...args);
+              if (success)
+                  fulfill(success);
+              else
+                  requestAnimationFrame(onRaf);
+          }
+      }
+      function pollInterval(pollInterval) {
+          let fulfill;
+          const result = new Promise((x) => (fulfill = x));
+          onTimeout();
+          return result;
+          function onTimeout() {
+              if (timedOut) {
+                  fulfill();
+                  return;
+              }
+              const success = predicate(...args);
+              if (success)
+                  fulfill(success);
+              else
+                  setTimeout(onTimeout, pollInterval);
+          }
+      }
+  }
+  JAVASCRIPT
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppeteer-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - YusukeIwaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-29 00:00:00.000000000 Z
+date: 2020-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -258,6 +258,7 @@ files:
 - docs/Puppeteer/Viewport.html
 - docs/Puppeteer/WaitTask.html
 - docs/Puppeteer/WaitTask/TerminatedError.html
+- docs/Puppeteer/WaitTask/TimeoutError.html
 - docs/Puppeteer/WebSocket.html
 - docs/Puppeteer/WebSocket/DriverImpl.html
 - docs/Puppeteer/WebSocketTransport.html