puppeteer-ruby 0.0.2

data/lib/puppeteer/emulation_manager.rb

@@ -0,0 +1,46 @@
+class Puppeteer::EmulationManager
+  using Puppeteer::AsyncAwaitBehavior
+
+  # @param {!Puppeteer.CDPSession} client
+  def initialize(client)
+    @client = client
+    @emulating_mobile = false
+    @has_touch = false
+  end
+
+  # @param viewport [Puppeteer::Viewport]
+  # @return [true|false]
+  def emulate_viewport(viewport)
+    mobile = viewport.mobile?
+    width = viewport.width
+    height = viewport.height
+    device_scale_factor = viewport.device_scale_factor
+    # /** @type {Protocol.Emulation.ScreenOrientation} */
+    # const screenOrientation = viewport.isLandscape ? { angle: 90, type: 'landscapePrimary' } : { angle: 0, type: 'portraitPrimary' };
+    has_touch = viewport.has_touch?
+
+    await_all(
+      @client.async_send_message('Emulation.setDeviceMetricsOverride',
+        mobile: mobile,
+        width: width,
+        height: height,
+        deviceScaleFactor: device_scale_factor,
+        # screenOrientation: screen_orientation,
+      ),
+      @client.async_send_message('Emulation.setTouchEmulationEnabled',
+        enabled: has_touch,
+      ),
+    )
+
+    reload_needed = @emulating_mobile != mobile || @hasTouch != has_touch;
+    @emulating_mobile = mobile
+    @has_touch = has_touch
+    return reload_needed
+  end
+
+  # @param viewport [Puppeteer::Viewport]
+  # @return [Future<true|false>]
+  async def async_emulate_viewport(viewport)
+    emulate_viewport(viewport)
+  end
+end

data/lib/puppeteer/errors.rb

@@ -0,0 +1,4 @@
+# ref: https://github.com/puppeteer/puppeteer/blob/master/lib/Errors.js
+class Puppeteer::TimeoutError < StandardError ; end
+
+class Puppeteer::WebSocktTransportError < StandardError ; end

data/lib/puppeteer/event_callbackable.rb

@@ -0,0 +1,88 @@
+require 'securerandom'
+
+module Puppeteer::EventCallbackable
+  class EventListeners
+    include Enumerable
+
+    def initialize
+      @listeners = {}
+    end
+
+    # @return [String] Listener ID
+    def add(&block)
+      id = SecureRandom.hex(8)
+      @listeners[id] = block
+      id
+    end
+
+    # @param id [String] Listener ID returned on #add
+    def delete(id)
+      @listeners.delete(id)
+    end
+
+    # @implement Enumerable#each
+    def each(&block)
+      @listeners.values.each(&block)
+    end
+  end
+
+  def add_event_listener(event_name, &block)
+    @event_listeners ||= {}
+    (@event_listeners[event_name] ||= EventListeners.new).add(&block)
+  end
+
+  def remove_event_listener(*id_args)
+    (@event_listeners ||= {}).each do |event_name, listeners|
+      id_args.each do |id|
+        listeners.delete(id)
+      end
+    end
+  end
+
+  def on_event(event_name, &block)
+    @event_callbackable_handlers ||= {}
+    @event_callbackable_handlers[event_name] = block
+  end
+
+  def emit_event(event_name, *args, **kwargs)
+    @event_callbackable_handlers ||= {}
+    @event_listeners ||= {}
+
+    if kwargs.empty?
+      # In Ruby's specification (version < 2.7),
+      # `method(:x).call(*args, **kwargs)` is equivalent to `x(*args, {})`
+      # It often causes unexpected ArgumentError.
+      #
+      # ----------------
+      # def greet
+      #   puts 'Hello!'
+      # end
+      #
+      # def call_me(*args, **kwargs)
+      #   greet(*args, **kwargs) # => 'Hello!'
+      #
+      #   method(:greet).call(*args, **kwargs) # => `greet': wrong number of arguments (given 1, expected 0) (ArgumentError)
+      # end
+      #
+      # call_me
+      # ----------------
+      #
+      # This behavior is really annoying, and should be avoided, because we often want to set event handler as below:
+      #
+      # `on_event 'Some.Event.awesome', &method(:handle_awesome_event)`
+      #
+      # So Let's avoid it by checking kwargs.
+      @event_callbackable_handlers[event_name]&.call(*args)
+      @event_listeners[event_name]&.each do |proc|
+        proc.call(*args)
+      end
+    else
+      @event_callbackable_handlers[event_name]&.call(*args, **kwargs)
+      @event_listeners[event_name]&.each do |proc|
+        proc.call(*args, **kwargs)
+      end
+    end
+
+    event_name
+  end
+end

data/lib/puppeteer/execution_context.rb

@@ -0,0 +1,230 @@
+class Puppeteer::ExecutionContext
+  include Puppeteer::IfPresent
+  using Puppeteer::AsyncAwaitBehavior
+
+  EVALUATION_SCRIPT_URL = '__puppeteer_evaluation_script__'
+  SOURCE_URL_REGEX = /^[\040\t]*\/\/[@#] sourceURL=\s*(\S*?)\s*$/m
+
+  # @param client [Puppeteer::CDPSession]
+  # @param context_payload [Hash]
+  # @param world [Puppeteer::DOMWorld?]
+  def initialize(client, context_payload, world)
+    @client = client
+    @world = world
+    @context_id = context_payload['id']
+  end
+
+  attr_reader :client, :world
+
+  # @return [Puppeteer::Frame]
+  def frame
+    if_present(@world) do |world|
+      world.frame
+    end
+  end
+
+  # @param page_function [String]
+  # @return [Object]
+  def evaluate(page_function, *args)
+    evaluate_internal(true, page_function, *args)
+  end
+
+  # @param page_function [String]
+  # @return [Puppeteer::JSHandle]
+  def evaluate_handle(page_function, *args)
+    evaluate_internal(false, page_function, *args)
+  end
+
+  class JavaScriptExpression
+    def initialize(execution_context, expression, return_by_value)
+      @execution_context = execution_context
+      @expression = expression
+      @return_by_value = return_by_value
+    end
+
+    # @param client [Puppeteer::CDPSession]
+    # @param context_id [String]
+    # @return [Object|JSHandle]
+    def evaluate_with(client:, context_id:)
+      result = client.send_message('Runtime.evaluate',
+        expression: expression_with_source_url,
+        contextId: context_id,
+        returnByValue: @return_by_value,
+        awaitPromise: true,
+        userGesture: true,
+      )
+      # }).catch(rewriteError);
+
+      exception_details = result["exceptionDetails"]
+      if exception_details
+        raise EvaluationError.new("Evaluation failed: #{exception_details}")
+      end
+
+      remote_object = Puppeteer::RemoteObject.new(result['result'])
+      if @return_by_value
+        remote_object.value
+      else
+        Puppeteer::JSHandle.create(
+          context: @execution_context,
+          remote_object: remote_object,
+        )
+      end
+    end
+
+    private def suffix
+      "//# sourceURL=#{EVALUATION_SCRIPT_URL}"
+    end
+
+    private def expression_with_source_url
+      if SOURCE_URL_REGEX.match?(@expression)
+        @expression
+      else
+        "#{@expression}\n#{suffix}"
+      end
+    end
+  end
+
+  class JavaScriptFunction
+    include Puppeteer::IfPresent
+
+    def initialize(execution_context, expression, args, return_by_value)
+      @execution_context = execution_context
+      @expression = expression
+      @return_by_value = return_by_value
+      @args = args
+    end
+
+    # @param client [Puppeteer::CDPSession]
+    # @param context_id [String]
+    # @return [Object|JSHandle]
+    def evaluate_with(client:, context_id:)
+      # `function` can be omitted in JS after ES2015.
+      # https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Operators/Object_initializer
+      #
+      # Original puppeteer implementation take it into consideration.
+      # But we don't support the syntax here.
+
+      result = client.send_message('Runtime.callFunctionOn',
+        functionDeclaration: "#{@expression}\n#{suffix}\n",
+        executionContextId: context_id,
+        arguments: converted_args,
+        returnByValue: @return_by_value,
+        awaitPromise: true,
+        userGesture: true,
+      ) #.catch(rewriteError);
+
+      exception_details = result["exceptionDetails"]
+      remote_object = Puppeteer::RemoteObject.new(result["result"])
+
+      if exception_details
+        raise EvaluationError.new("Evaluation failed: #{exceptionDetails}")
+      end
+
+      if @return_by_value
+        remote_object.value
+      else
+        Puppeteer::JSHandle.create(
+          context: @execution_context,
+          remote_object: remote_object,
+        )
+      end
+    end
+
+    private def converted_args
+      #     if (typeof arg === 'bigint') // eslint-disable-line valid-typeof
+      #       return { unserializableValue: `${arg.toString()}n` };
+      #     if (Object.is(arg, -0))
+      #       return { unserializableValue: '-0' };
+      #     if (Object.is(arg, Infinity))
+      #       return { unserializableValue: 'Infinity' };
+      #     if (Object.is(arg, -Infinity))
+      #       return { unserializableValue: '-Infinity' };
+      #     if (Object.is(arg, NaN))
+      #       return { unserializableValue: 'NaN' };
+      @args.map do |arg|
+        if arg && arg.is_a?(Puppeteer::JSHandle)
+          if arg.context != @execution_context
+            raise EvaluationError.new('JSHandles can be evaluated only in the context they were created!')
+          elsif arg.disposed?
+            raise EvaluationError.new('JSHandles is disposed!')
+          end
+
+          arg.remote_object.converted_arg
+        else
+          { value: arg }
+        end
+      end
+    end
+
+    #   /**
+    #    * @param {!Error} error
+    #    * @return {!Protocol.Runtime.evaluateReturnValue}
+    #    */
+    #   function rewriteError(error) {
+    #     if (error.message.includes('Object reference chain is too long'))
+    #       return {result: {type: 'undefined'}};
+    #     if (error.message.includes('Object couldn\'t be returned by value'))
+    #       return {result: {type: 'undefined'}};
+
+    #     if (error.message.endsWith('Cannot find context with specified id') || error.message.endsWith('Inspected target navigated or closed'))
+    #       throw new Error('Execution context was destroyed, most likely because of a navigation.');
+    #     throw error;
+    #   }
+
+    private def suffix
+      "//# sourceURL=#{EVALUATION_SCRIPT_URL}"
+    end
+  end
+
+  class EvaluationError < StandardError ; end
+
+  # @param return_by_value [Boolean]
+  # @param page_function [String]
+  # @return [Object|Puppeteer::JSHandle]
+  private def evaluate_internal(return_by_value, page_function, *args)
+    # `function` can be omitted in JS after ES2015.
+    # https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Operators/Object_initializer
+    # But we don't support the syntax here.
+    js_object =
+      if ["=>", "async", "function"].any? { |keyword| page_function.include?(keyword) }
+        JavaScriptFunction.new(self, page_function, args, return_by_value)
+      else
+        JavaScriptExpression.new(self, page_function, return_by_value)
+      end
+
+    js_object.evaluate_with(
+      client: @client,
+      context_id: @context_id,
+    )
+  end
+
+  # /**
+  #  * @param {!JSHandle} prototypeHandle
+  #  * @return {!Promise<!JSHandle>}
+  #  */
+  # async queryObjects(prototypeHandle) {
+  #   assert(!prototypeHandle._disposed, 'Prototype JSHandle is disposed!');
+  #   assert(prototypeHandle._remoteObject.objectId, 'Prototype JSHandle must not be referencing primitive value');
+  #   const response = await this._client.send('Runtime.queryObjects', {
+  #     prototypeObjectId: prototypeHandle._remoteObject.objectId
+  #   });
+  #   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));
+  # }
+end

data/lib/puppeteer/frame.rb

@@ -0,0 +1,278 @@
+class Puppeteer::Frame
+  # @param {!FrameManager} frameManager
+  # @param {!Puppeteer.CDPSession} client
+  # @param {?Frame} parentFrame
+  # @param {string} frameId
+  def initialize(frame_manager, client, parent_frame, frame_id)
+    @frame_manager = frame_manager
+    @client = client
+    @parent_frame = parent_frame
+    @id = frame_id
+    @detached = false
+
+    @loader_id = ''
+    @lifecycle_events = Set.new
+    @main_world = Puppeteer::DOMWorld.new(frame_manager, self, frame_manager.timeout_settings)
+    @secondary_world = Puppeteer::DOMWorld.new(frame_manager, self, frame_manager.timeout_settings)
+    @child_frames = Set.new
+    if parent_frame
+      parent_frame._child_frames << self
+    end
+  end
+
+  attr_accessor :frame_manager, :id, :loader_id, :lifecycle_events, :main_world, :secondary_world
+
+  # @param url [String]
+  # @param rederer [String]
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  # @return [Puppeteer::Response]
+  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
+
+  # @param timeout [number|nil]
+  # @param wait_until [string|nil] 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2'
+  def wait_for_navigation(timeout: nil, wait_until: nil)
+    @frame_manager.wait_for_frame_navigation(self, timeout: timeout, wait_until: wait_until)
+  end
+
+  def execution_context
+    @main_world.execution_context
+  end
+
+  # @param {Function|string} pageFunction
+  # @return {!Promise<!Puppeteer.JSHandle>}
+  def evaluate_handle(page_function, *args)
+    @main_world.evaluate_handle(page_function, *args)
+  end
+
+  # @param {Function|string} pageFunction
+  # @param {!Array<*>} args
+  def evaluate(page_function, *args)
+    @main_world.evaluate(page_function, *args)
+  end
+
+  # `$()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param {string} selector
+  # @return {!Promise<?Puppeteer.ElementHandle>}
+  def S(selector)
+    @main_world.S(selector)
+  end
+
+
+  # `$x()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param {string} expression
+  # @return {!Promise<!Array<!Puppeteer.ElementHandle>>}
+  def Sx(expression)
+    @main_world.Sx(expression)
+  end
+
+
+  # `$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param {string} selector
+  # @param {Function|string} pageFunction
+  # @param {!Array<*>} args
+  # @return {!Promise<(!Object|undefined)>}
+  def Seval(selector, page_function, *args)
+    @main_world.Seval(selector, page_function, *args)
+  end
+
+  # `$$eval()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param {string} selector
+  # @param {Function|string} pageFunction
+  # @param {!Array<*>} args
+  # @return {!Promise<(!Object|undefined)>}
+  def SSeval(selector, page_function, *args)
+    @main_world.SSeval(selector, page_function, *args)
+  end
+
+  # `$$()` in JavaScript. $ is not allowed to use as a method name in Ruby.
+  # @param {string} selector
+  # @return {!Promise<!Array<!Puppeteer.ElementHandle>>}
+  def SS(selector)
+    @main_world.SS(selector)
+  end
+
+  def content
+    @secondary_world.content
+  end
+
+  # @param {string} html
+  # @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
+  def set_content(html, timeout: nil, wait_until: nil)
+    @secondary_world.set_content(html, timeout: timeout, wait_until: wait_until)
+  end
+
+  # @return [String]
+  def name
+    @name || ''
+  end
+
+  # @return [String]
+  def url
+    @url
+  end
+
+  # @return [Frame?]
+  def parent_frame
+    @parent_frame
+  end
+
+  protected def _child_frames
+    @child_frames
+  end
+
+  def child_frames
+    @child_frames.dup
+  end
+
+  def detached?
+    @detached
+  end
+
+  # @param style_tag [Puppeteer::Page::ScriptTag]
+  # @return {!Promise<!ElementHandle>}
+  def add_script_tag(script_tag)
+    @main_world.add_script_tag(script_tag)
+  end
+
+  # @param style_tag [Puppeteer::Page::StyleTag]
+  # @return {!Promise<!ElementHandle>}
+  def add_style_tag(style_tag)
+    @main_world.add_style_tag(style_tag)
+  end
+
+  # @param {string} selector
+  # @param {!{delay?: number, button?: "left"|"right"|"middle", clickCount?: number}=} options
+  def click(selector, delay: nil, button: nil, click_count: nil)
+    @secondary_world.click(selector, delay: delay, button: button, click_count: click_count)
+  end
+
+  # @param {string} selector
+  def focus(selector)
+    @secondary_world.focus(selector)
+  end
+
+  # @param {string} selector
+  def hover(selector)
+    @secondary_world.hover(selector)
+  end
+
+  # @param {string} selector
+  # @param {!Array<string>} values
+  # @return {!Promise<!Array<string>>}
+  def select(selector, *values)
+    @secondary_world.select(selector, *values)
+  end
+
+  # @param {string} selector
+  def tap(selector)
+    @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)
+  end
+
+  # /**
+  #  * @param {(string|number|Function)} selectorOrFunctionOrTimeout
+  #  * @param {!Object=} options
+  #  * @param {!Array<*>} args
+  #  * @return {!Promise<?Puppeteer.JSHandle>}
+  #  */
+  # waitFor(selectorOrFunctionOrTimeout, options = {}, ...args) {
+  #   const xPathPattern = '//';
+
+  #   if (helper.isString(selectorOrFunctionOrTimeout)) {
+  #     const string = /** @type {string} */ (selectorOrFunctionOrTimeout);
+  #     if (string.startsWith(xPathPattern))
+  #       return this.waitForXPath(string, options);
+  #     return this.waitForSelector(string, options);
+  #   }
+  #   if (helper.isNumber(selectorOrFunctionOrTimeout))
+  #     return new Promise(fulfill => setTimeout(fulfill, /** @type {number} */ (selectorOrFunctionOrTimeout)));
+  #   if (typeof selectorOrFunctionOrTimeout === 'function')
+  #     return this.waitForFunction(selectorOrFunctionOrTimeout, options, ...args);
+  #   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>}
+  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
+      return nil
+    end
+    main_execution_context = @main_world.execution_context
+    result = main_execution_context.adopt_element_handle(handle)
+    handle.dispose
+    return result
+  end
+
+  # @param {string} xpath
+  # @param {!{visible?: boolean, hidden?: boolean, timeout?: number}=} options
+  # @return {!Promise<?Puppeteer.ElementHandle>}
+  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
+      return nil
+    end
+    main_execution_context = @main_world.execution_context
+    result = main_execution_context.adopt_element_handle(handle)
+    handle.dispose
+    return result
+  end
+
+  # @param {Function|string} pageFunction
+  # @param {!{polling?: string|number, timeout?: number}=} options
+  # @param {!Array<*>} args
+  # @return {!Promise<!Puppeteer.JSHandle>}
+  def wait_for_function(page_function, options = {}, *args)
+    @main_world.wait_for_function(page_function, options, *args)
+  end
+
+  def title
+    @secondary_world.title
+  end
+
+  # @param frame_payload [Hash]
+  def navigated(frame_payload)
+    @name = frame_payload['name']
+    # TODO(lushnikov): remove this once requestInterception has loaderId exposed.
+    @navigation_url = frame_payload['url']
+    @url = frame_payload['url']
+  end
+
+  # @param url [String]
+  def navigated_within_document(url)
+    @url = url
+  end
+
+  def handle_lifecycle_event(loader_id, name)
+    if name == 'init'
+      @loader_id = loader_id
+      @lifecycle_events.clear
+    end
+    @lifecycle_events << name
+  end
+
+  def handle_loading_stopped
+    @lifecycle_events << 'DOMContentLoaded'
+    @lifecycle_events << 'load'
+  end
+
+  def detach
+    @detached = true
+    #   this._mainWorld._detach();
+    #   this._secondaryWorld._detach();
+    if @parent_frame
+      @parent_frame._child_frames.delete(self)
+    end
+    @parent_frame = nil
+  end
+end